Resolve typedefs.

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 213 matching lines @@
     }
     return result;
   }
 
   void resolveClass(ClassElement element) {
     if (element.isResolved || element.isBeingResolved) return;
     element.isBeingResolved = true;
     measure(() {
       ClassNode tree = element.parseNode(compiler);
       ClassResolverVisitor visitor =
-        new ClassResolverVisitor(compiler, element.getLibrary(), element);
+        new ClassResolverVisitor(compiler, element);
       visitor.visit(tree);
       element.isBeingResolved = false;
       element.isResolved = true;
 
       while (!toResolve.isEmpty()) {
         ClassElement classElement = toResolve.removeFirst();
         classElement.ensureResolved(compiler);
       }
 
       checkMembers(element);
@@ skipping 92 matching lines @@
           compiler, node.parameters, node.returnType, element));
     });
   }
 
   FunctionSignature resolveFunctionExpression(Element element,
                                               FunctionExpression node) {
     return measure(() => SignatureResolver.analyze(
       compiler, node.parameters, node.returnType, element));
   }
 
-  FunctionSignature resolveTypedef(TypedefElement element) {
+  void resolveTypedef(TypedefElement element) {
     return compiler.withCurrentElement(element, () {
-      Typedef node =
+      measure(() {
+        Typedef node =
           compiler.parser.measure(() => element.parseNode(compiler));
-      return measure(() => SignatureResolver.analyze(
-          compiler, node.formals, node.returnType, element));
+        TypedefResolverVisitor visitor =
+          new TypedefResolverVisitor(compiler, element);
+        visitor.visit(node);
+      });
     });
   }
 
   FunctionType computeFunctionType(Element element,
                                    FunctionSignature signature) {
     LinkBuilder<Type> parameterTypes = new LinkBuilder<Type>();
     for (Link<Element> link = signature.requiredParameters;
          !link.isEmpty();
          link = link.tail) {
        parameterTypes.addLast(link.head.computeType(compiler));
        // TODO(karlklose): optional parameters.
     }
     return new FunctionType(signature.returnType,
                             parameterTypes.toLink(),
                             element);
   }
 
   error(Node node, MessageKind kind, [arguments = const []]) {
     ResolutionError message = new ResolutionError(kind, arguments);
     compiler.reportError(node, message);
   }
+
+  warning(Node node, MessageKind kind, [arguments = const []]) {
+    ResolutionWarning message = new ResolutionWarning(kind, arguments);
+    compiler.reportWarning(node, message);
+  }
 }
 
 class InitializerResolver {
   final ResolverVisitor visitor;
   final Map<SourceString, Node> initialized;
   Link<Node> initializers;
   bool hasSuper;
 
   InitializerResolver(this.visitor)
     : initialized = new Map<SourceString, Node>(), hasSuper = false;
@@ skipping 178 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 63 matching lines @@
   int nestingLevel = 0;
 
   StatementScope()
       : labels = const EmptyLabelScope(),
         breakTargetStack = const EmptyLink<TargetElement>(),
         continueTargetStack = const EmptyLink<TargetElement>();
 
   LabelElement lookupLabel(String label) {
     return labels.lookup(label);
   }
+
   TargetElement currentBreakTarget() =>
     breakTargetStack.isEmpty() ? null : breakTargetStack.head;
 
   TargetElement currentContinueTarget() =>
     continueTargetStack.isEmpty() ? null : continueTargetStack.head;
 
   void enterLabelScope(Map<String, LabelElement> elements) {
     labels = new LabeledStatementLabelScope(labels, elements);
     nestingLevel++;
   }
@@ skipping 24 matching lines @@
 
   void exitSwitch() {
     nestingLevel--;
     breakTargetStack = breakTargetStack.tail;
     labels = labels.outer;
   }
 }
 
 class TypeResolver {
   final Compiler compiler;
+
   TypeResolver(this.compiler);
 
-  Element resolveTypeName(Scope context, TypeAnnotation node) {
+  Element resolveTypeName(Scope scope, TypeAnnotation node) {
     Identifier typeName = node.typeName.asIdentifier();
     Send send = node.typeName.asSend();
+    return resolveTypeNameInternal(scope, typeName, send);
+  }
+
+  Element resolveTypeNameInternal(Scope scope, Identifier typeName, Send send) {
     if (send !== null) {
       typeName = send.selector;
     }
     if (typeName.source.stringValue === 'void') {
       return compiler.types.voidType.element;
     } else if (send !== null) {
-      Element e = context.lookup(send.receiver.asIdentifier().source);
+      Element e = scope.lookup(send.receiver.asIdentifier().source);
       if (e !== null && e.kind === ElementKind.PREFIX) {
         // The receiver is a prefix. Lookup in the imported members.
         PrefixElement prefix = e;
         return prefix.lookupLocalMember(typeName.source);
       } else if (e !== null && e.kind === ElementKind.CLASS) {
         // The receiver is the class part of a named constructor.
         return e;
       } else {
         return null;
       }
     } else {
-      return context.lookup(typeName.source);
+      return scope.lookup(typeName.source);
     }
   }
 
+  // TODO(johnniwinther): Change  [onFailure] and [whenResolved] to use boolean
+  // flags instead of closures.
   Type resolveTypeAnnotation(TypeAnnotation node,
-                             [Scope inContext, ClassElement inClass,
+                             [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) {};
     }
     if (inClass !== null) {
-      inContext = new ClassScope(inClass, inClass.getLibrary());
+      inScope = inClass.buildScope();//new ClassScope(inClass, inClass.getLibrary());

[ahe, 2012/08/02 06:43:14]

Remove comment.

     }
-    if (inContext === null) {
+    if (inScope === null) {
       compiler.internalError('resolveTypeAnnotation: no scope specified');
     }
-    return resolveTypeAnnotationInContext(inContext, node, onFailure,
+    return resolveTypeAnnotationInContext(inScope, node, onFailure,
                                           whenResolved);
   }
 
-  Type resolveTypeAnnotationInContext(Scope context, TypeAnnotation node,
+  Type resolveTypeAnnotationInContext(Scope scope, TypeAnnotation node,
                                       onFailure, whenResolved) {
-    Element element = resolveTypeName(context, node);
+    Element element = resolveTypeName(scope, node);
     Type type;
     if (element === null) {
       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(context,
-                                                          typeArguments.head,
-                                                          onFailure,
-                                                          whenResolved);
-            arguments.addLast(argType);
-          }
-          if (index < cls.typeParameters.length) {
-            onFailure(node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
-          }
-        }
-        if (cls.typeParameters.length == 0) {
+        compiler.resolver.toResolve.add(cls);

[ahe, 2012/08/02 06:43:14]

Please add a comment to explain why it is safe to not resolve the class
immediately.

+        cls.computeType(compiler);
+        Link<Type> typeArguments = resolveTypeArguments(
+            node, cls.typeVariables,
+            scope, onFailure, whenResolved);
+        if (cls.typeVariables.isEmpty()) {
           // Return the canonical type if it has no type parameters.
           type = cls.computeType(compiler);
         } else {
-          type = new InterfaceType(cls, arguments.toLink());
+          type = new InterfaceType(cls, typeArguments);
         }
       } else if (element.isTypedef()) {
-        type = element.computeType(compiler);
+        TypedefElement typdef = element;
+        // TODO(johnniwinther): Do we need to resolve the typedef?
+        typdef.computeType(compiler);
+        Link<Type> typeArguments = resolveTypeArguments(
+            node, typdef.typeVariables,
+            scope, onFailure, whenResolved);
+        if (typdef.typeVariables.isEmpty()) {
+          // Return the canonical type if it has no type parameters.
+          type = typdef.computeType(compiler);
+        } else {
+          type = new TypedefType(typdef, typeArguments);
+        }
       } 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<TypeVariableType> 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);
+      }
+      Node typeArgument = typeArguments.head;
+      Type argType;
+      if (typeArgument is TypeAnnotation) {

[ahe, 2012/08/02 06:43:14]

typeArgument.asTypeAnnotation() !== null

+        argType = resolveTypeAnnotationInContext(scope,
+                                                 typeArgument,
+                                                 onFailure,
+                                                 whenResolved);
+      } else if (typeArgument is TypeVariable) {

[ahe, 2012/08/02 06:43:14]

asTypeVariable

+        // This happens in default clauses!

[ahe, 2012/08/02 06:43:14]

This case is really not making any sense to me.

+        Element element = resolveTypeNameInternal(scope, typeArgument.name,
+                                                  null);
+        if (element === null) {
+          onFailure(node, MessageKind.CANNOT_RESOLVE_TYPE, [typeArgument.name]);

[ahe, 2012/08/02 06:43:14]

Doesn't the spec say that the type variables must be identical? So if I have:

interface Foo default Bar<X> {} 

class Bar<Y> {}

The error is that X is not Y. So what you need to do here is run through the
type parameters of the class and the default clause and compare them. I don't
think this is the right place to do so. In other words, we shouldn't treat a
default clause as regular TypeAnnotation.

+        } else if (!element.impliesType()) {
+          onFailure(node, MessageKind.NOT_A_TYPE, [typeArgument.name]);
+        } else if (!element.isTypeVariable()) {
+          onFailure(node, MessageKind.GENERIC,
+              ["Default clauses can only contain type variables."]);
+        } else {
+          TypeVariableElement typeVariableElement = element;
+          argType = typeVariableElement.type;
+        }
+     }
+      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 context;
+  Scope scope;
   ClassElement currentClass;
   bool typeRequired = false;
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION;
 
   ResolverVisitor(Compiler compiler, Element element)
     : this.mapping  = new TreeElementMapping(),
       this.enclosingElement = element,
       inInstanceContext = element.isInstanceMember()
           || element.isGenerativeConstructor(),
       this.currentClass = element.isMember() ? element.enclosingElement : null,
       this.statementScope = new StatementScope(),
       typeResolver = new TypeResolver(compiler),
+      scope = element.buildEnclosingScope(),
       super(compiler) {
-    LibraryElement library = element.getLibrary();
-    element = element.getEnclosingMember();
-    if (element !== null) {
-      context = new ClassScope(element.enclosingElement, library);
-    } else {
-      this.context = new TopScope(library);
-    }
+            if (element.enclosingElement == null) {
+              print(element);
+            }
   }
 
   Enqueuer get world() => compiler.enqueuer.resolution;
 
   Element lookup(Node node, SourceString name) {
-    Element result = context.lookup(name);
+    Element result = scope.lookup(name);
     if (!inInstanceContext && result != null && result.isInstanceMember()) {
       error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
     }
     return result;
   }
 
   // Create, or reuse an already created, statement element for a statement.
   TargetElement getOrCreateTargetElement(Node statement) {
     TargetElement element = mapping[statement];
     if (element === null) {
@@ skipping 25 matching lines @@
       return null;
     } else if (node.isSuper()) {
       if (!inInstanceContext) error(node, MessageKind.NO_SUPER_IN_STATIC);
       if ((ElementCategory.SUPER & allowedCategory) == 0) {
         error(node, MessageKind.INVALID_USE_OF_SUPER);
       }
       return null;
     } else {
       Element element = lookup(node, node.source);
       if (element === null) {
-        if (!inInstanceContext) error(node, MessageKind.CANNOT_RESOLVE, [node]);
+        if (!inInstanceContext) {
+          error(node, MessageKind.CANNOT_RESOLVE, [node]);
+        }
       } else {
         if ((element.kind.category & allowedCategory) == 0) {
           // TODO(ahe): Improve error message. Need UX input.
           error(node, MessageKind.GENERIC, ["is not an expression $element"]);
         }
       }
       return useElement(node, element);
     }
   }
 
   Element visitTypeAnnotation(TypeAnnotation node) {
     Type type = resolveTypeAnnotation(node);
     if (type !== null) return type.element;
     return null;
   }
 
   Element defineElement(Node node, Element element,
                         [bool doAddToScope = true]) {
     compiler.ensure(element !== null);
     mapping[node] = element;
     if (doAddToScope) {
-      Element existing = context.add(element);
+      Element existing = scope.add(element);
       if (existing != element) {
         error(node, MessageKind.DUPLICATE_DEFINITION, [node]);
       }
     }
     return element;
   }
 
   Element useElement(Node node, Element element) {
     if (element === null) return null;
     mapping[node] = element;
@@ skipping 20 matching lines @@
 
   Type useType(TypeAnnotation annotation, Type type) {
     if (type !== null) {
       mapping.setType(annotation, type);
       useElement(annotation, type.element);
     }
     return type;
   }
 
   void setupFunction(FunctionExpression node, FunctionElement function) {
-    context = new MethodScope(context, function);
+    scope = new MethodScope(scope, function);
     if (node.returnType !== null) resolveTypeAnnotation(node.returnType);
     // Put the parameters in scope.
     FunctionSignature functionParameters =
         function.computeSignature(compiler);
     Link<Node> parameterNodes = node.parameters.nodes;
     functionParameters.forEachParameter((Element element) {
       if (element == functionParameters.optionalParameters.head) {
         NodeList nodes = parameterNodes.head;
         parameterNodes = nodes.nodes;
       }
@@ skipping 16 matching lines @@
   }
 
   visitCascadeReceiver(CascadeReceiver node) {
     visit(node.expression);
   }
 
   Element visitClassNode(ClassNode node) {
     cancel(node, "shouldn't be called");
   }
 
-  visitIn(Node node, Scope scope) {
-    context = scope;
+  visitIn(Node node, Scope nestedScope) {
+    scope = nestedScope;
     Element element = visit(node);
-    context = context.parent;
+    scope = scope.parent;
     return element;
   }
 
   /**
    * Introduces new default targets for break and continue
    * before visiting the body of the loop
    */
-  visitLoopBodyIn(Node loop, Node body, Scope scope) {
+  visitLoopBodyIn(Node loop, Node body, Scope bodyScope) {
     TargetElement element = getOrCreateTargetElement(loop);
     statementScope.enterLoop(element);
-    visitIn(body, scope);
+    visitIn(body, bodyScope);
     statementScope.exitLoop();
     if (!element.isTarget) {
       mapping.remove(loop);
     }
   }
 
   visitBlock(Block node) {
-    visitIn(node.statements, new BlockScope(context));
+    visitIn(node.statements, new BlockScope(scope));
   }
 
   visitDoWhile(DoWhile node) {
-    visitLoopBodyIn(node, node.body, new BlockScope(context));
+    visitLoopBodyIn(node, node.body, new BlockScope(scope));
     visit(node.condition);
   }
 
   visitEmptyStatement(EmptyStatement node) { }
 
   visitExpressionStatement(ExpressionStatement node) {
     visit(node.expression);
   }
 
   visitFor(For node) {
-    Scope scope = new BlockScope(context);
-    visitIn(node.initializer, scope);
-    visitIn(node.condition, scope);
-    visitIn(node.update, scope);
-    visitLoopBodyIn(node, node.body, scope);
+    Scope blockScope = new BlockScope(scope);
+    visitIn(node.initializer, blockScope);
+    visitIn(node.condition, blockScope);
+    visitIn(node.update, blockScope);
+    visitLoopBodyIn(node, node.body, blockScope);
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.function.name !== null);
     visit(node.function);
     FunctionElement functionElement = mapping[node.function];
     // TODO(floitsch): this might lead to two errors complaining about
     // shadowing.
     defineElement(node, functionElement);
   }
 
   visitFunctionExpression(FunctionExpression node) {
     visit(node.returnType);
     SourceString name;
     if (node.name === null) {
       name = const SourceString("");
     } else {
       name = node.name.asIdentifier().source;
     }
     FunctionElement enclosing = new FunctionElement.node(
         name, node, ElementKind.FUNCTION, new Modifiers.empty(),
-        context.element);
+        scope.element);
     setupFunction(node, enclosing);
     defineElement(node, enclosing, doAddToScope: node.name !== null);
 
     // Run the body in a fresh statement scope.
     StatementScope oldScope = statementScope;
     statementScope = new StatementScope();
     visit(node.body);
     statementScope = oldScope;
 
-    context = context.parent;
+    scope = scope.parent;
   }
 
   visitIf(If node) {
     visit(node.condition);
     visit(node.thenPart);
     visit(node.elsePart);
   }
 
   static bool isLogicalOperator(Identifier op) {
     String str = op.source.stringValue;
@@ skipping 249 matching lines @@
   visitVariableDefinitions(VariableDefinitions node) {
     visit(node.type);
     VariableDefinitionsVisitor visitor =
         new VariableDefinitionsVisitor(compiler, node, this,
                                        ElementKind.VARIABLE);
     visitor.visit(node.definitions);
   }
 
   visitWhile(While node) {
     visit(node.condition);
-    visitLoopBodyIn(node, node.body, new BlockScope(context));
+    visitLoopBodyIn(node, node.body, new BlockScope(scope));
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     visit(node.expression);
   }
 
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
 
     FunctionElement constructor = resolveConstructor(node);
@@ skipping 15 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;
   }
 
   Type resolveTypeAnnotation(TypeAnnotation node) {
     Function report = typeRequired ? error : warning;
-    return typeResolver.resolveTypeAnnotation(node, inContext: context,
+    return typeResolver.resolveTypeAnnotation(node, inScope: scope,
                                               onFailure: report,
                                               whenResolved: useType);
   }
 
   visitModifiers(Modifiers node) {
     // TODO(ngeoffray): Implement this.
     unimplemented(node, 'modifiers');
   }
 
   visitLiteralList(LiteralList node) {
@@ skipping 64 matching lines @@
         unimplemented(node, "continue to switch case");
       }
       label.setContinueTarget();
       mapping[node.target] = label;
     }
     mapping[node] = target;
   }
 
   visitForIn(ForIn node) {
     visit(node.expression);
-    Scope scope = new BlockScope(context);
+    Scope blockScope = new BlockScope(scope);
     Node declaration = node.declaredIdentifier;
-    visitIn(declaration, scope);
-    visitLoopBodyIn(node, node.body, scope);
+    visitIn(declaration, blockScope);
+    visitLoopBodyIn(node, node.body, blockScope);
 
     // TODO(lrn): Also allow a single identifier.
     if ((declaration is !Send || declaration.asSend().selector is !Identifier)
         && (declaration is !VariableDefinitions ||
         !declaration.asVariableDefinitions().definitions.nodes.tail.isEmpty()))
     {
       // The variable declaration is either not an identifier, not a
       // declaration, or it's declaring more than one variable.
       error(node.declaredIdentifier, MessageKind.INVALID_FOR_IN, []);
     }
@@ skipping 99 matching lines @@
         TargetElement targetElement = label.target;
         SwitchCase switchCase = targetElement.statement;
         mapping.remove(switchCase);
         mapping.remove(label.label);
       }
     });
   }
 
   visitSwitchCase(SwitchCase node) {
     node.labelsAndCases.accept(this);
-    visitIn(node.statements, new BlockScope(context));
+    visitIn(node.statements, new BlockScope(scope));
   }
 
   visitCaseMatch(CaseMatch node) {
     visit(node.expression);
   }
 
   visitTryStatement(TryStatement node) {
     visit(node.tryBlock);
     if (node.catchBlocks.isEmpty() && node.finallyBlock == null) {
       // TODO(ngeoffray): The precise location is
       // node.getEndtoken.next. Adjust when issue #1581 is fixed.
       error(node, MessageKind.NO_CATCH_NOR_FINALLY);
     }
     visit(node.catchBlocks);
     visit(node.finallyBlock);
   }
 
   visitCatchBlock(CatchBlock node) {
-    Scope scope = new BlockScope(context);
+    Scope blockScope = new BlockScope(scope);
     if (node.formals.isEmpty()) {
       error(node, MessageKind.EMPTY_CATCH_DECLARATION);
     } else if (!node.formals.nodes.tail.isEmpty()
                && !node.formals.nodes.tail.tail.isEmpty()) {
       for (Node extra in node.formals.nodes.tail.tail) {
         error(extra, MessageKind.EXTRA_CATCH_DECLARATION);
       }
     }
-    visitIn(node.formals, scope);
-    visitIn(node.block, scope);
+    visitIn(node.formals, blockScope);
+    visitIn(node.block, blockScope);
   }
 
   visitTypedef(Typedef node) {
     unimplemented(node, 'typedef');
   }
 }
 
-class ClassResolverVisitor extends CommonResolverVisitor<Type> {
-  Scope context;
-  ClassElement classElement;
+class TypeDefinitionVisitor extends CommonResolverVisitor<Type> {
+  Scope scope;
+  TypeDeclarationElement element;
+  TypeResolver typeResolver;
 
-  ClassResolverVisitor(Compiler compiler, LibraryElement library,
-                       ClassElement this.classElement)
-    : context = new TopScope(library),
-      super(compiler);
+  TypeDefinitionVisitor(Compiler compiler, TypeDeclarationElement element)
+      : this.element = element,
+        scope = element.enclosingElement.buildScope(),
+        typeResolver = new TypeResolver(compiler),
+        super(compiler);
 
-  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;
-      context = new TypeVariablesScope(context, classElement);
-    }
+  void resolveTypeVariableBounds(NodeList node) {
+    if (node === null) return;
+
+    var nameSet = new Set<SourceString>();
     // 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];
+    Link<TypeVariableType> 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(typeVariable.name);
+
+      TypeVariableElement variableElement = typeVariable.element;
       if (typeNode.bound !== null) {
-        Type boundType = visit(typeNode.bound);
+        Type boundType = typeResolver.resolveTypeAnnotation(
+          typeNode.bound,
+          inScope: scope,
+          onFailure: warning);
         if (boundType !== null && boundType.element == variableElement) {
           warning(node, MessageKind.CYCLIC_TYPE_VARIABLE,
-                  [variableElement.name]);
+                 [variableElement.name]);
         } else if (boundType !== null) {
           variableElement.bound = boundType;
         } else {
           variableElement.bound = compiler.objectClass.computeType(compiler);
         }
       }
+      nodeLink = nodeLink.tail;
+      typeLink = typeLink.tail;
     }
+  }
+}
+
+class TypedefResolverVisitor extends TypeDefinitionVisitor {
+  TypedefElement get element() => super.element;
+
+  TypedefResolverVisitor(Compiler compiler, TypedefElement typedefElement)
+      : super(compiler, typedefElement);
+
+  visitTypedef(Typedef node) {
+    TypedefType type = element.computeType(compiler);
+    scope = new TypeDeclarationScope(scope, element);
+    resolveTypeVariableBounds(node.typeParameters);
+
+    element.functionSignature = SignatureResolver.analyze(
+        compiler, node.formals, node.returnType, element);
+
+    element.alias = compiler.computeFunctionType(
+        element, element.functionSignature);
+
+    // TODO(johnniwinther): Check for cyclic references in the typedef alias.
+  }
+}
+
+class ClassResolverVisitor extends TypeDefinitionVisitor {
+  ClassElement get element() => super.element;
+
+  ClassResolverVisitor(Compiler compiler, ClassElement classElement)
+    : super(compiler, classElement);
+
+  visitClassNode(ClassNode node) {
+    compiler.ensure(element !== null);
+    compiler.ensure(!element.isResolved);
+
+    InterfaceType type = element.computeType(compiler);
+    scope = new TypeDeclarationScope(scope, element);
+    resolveTypeVariableBounds(node.typeParameters);
+
     // Find super type.
-    Type supertype = visit(node.superclass);
+    Type supertype;
+    if (node.superclass != null) {
+      supertype = typeResolver.resolveTypeAnnotation(
+        node.superclass,
+        inScope: scope,
+        onFailure: error);
+    }
     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);
-    }
-    if (node.defaultClause !== null) {
-      classElement.defaultClass = visit(node.defaultClause);
+      element.supertype = new InterfaceType(objectElement);
     }
     for (Link<Node> link = node.interfaces.nodes;
          !link.isEmpty();
          link = link.tail) {
-      Type interfaceType = visit(link.head);
+      Type interfaceType = typeResolver.resolveTypeAnnotation(
+        link.head,
+        inScope: scope,
+        onFailure: error);
       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>());
+    if (node.defaultClause !== null) {
+      // TODO(johnniwinther): Handle the variables in default clauses separately

[ahe, 2012/08/02 06:43:14]

I don't think the code you have here is working at all, so I'd prefer if you
just replace lines 1822-1829 with a TODO.

+      // or encoded default clauses as something other than [TypeAnnotation].
+      element.defaultClass = typeResolver.resolveTypeAnnotation(
+          node.defaultClause,
+          inScope: scope,
+          onFailure: error);
+    }
+    addDefaultConstructorIfNeeded(element);
   }
 
-  Type visitTypeAnnotation(TypeAnnotation node) {
-    return visit(node.typeName);
-  }
-
-  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.
-        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]);
-      return null;
-    }
-    Element element = context.lookup(prefix.source);
-    if (element === null || element.kind !== ElementKind.PREFIX) {
-      error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
-      return null;
-    }
-    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): 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>();
+      cls.allSupertypes = const EmptyLink<InterfaceType>();
     } else if (supertype != null) {
       seen.add(cls);
-      Link<Type> superSupertypes =
-          getOrCalculateAllSupertypes(supertype.element, seen);
-      Link<Type> supertypes = new Link<Type>(supertype, superSupertypes);
-      for (Link<Type> interfaces = cls.interfaces;
+      ClassElement supertypeElement = supertype.element;
+      Link<InterfaceType> superSupertypes =
+          getOrCalculateAllSupertypes(supertypeElement, seen);
+      var superTypesBuilder = new LinkBuilder<InterfaceType>();
+      superTypesBuilder.addLast(supertype);
+
+      // Substitute type variables in supertypes.
+      for (Type superSupertype in superSupertypes) {
+        superTypesBuilder.addLast(superSupertype.subst(compiler,
+            supertype.typeArguments,
+            supertypeElement.computeType(compiler).typeArguments));
+      }
+
+      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 =
-      new SynthesizedConstructorElement(element);
+        new SynthesizedConstructorElement(element);
     element.constructors[element.name] = constructor;
     Type returnType = compiler.types.voidType;
     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);
+        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 VariableDefinitionsVisitor extends CommonResolverVisitor<SourceString> {
   VariableDefinitions definitions;
   ResolverVisitor resolver;
   ElementKind kind;
   VariableListElement variables;
 
   VariableDefinitionsVisitor(Compiler compiler,
                              this.definitions, this.resolver, this.kind)
     : super(compiler)
   {
     variables = new VariableListElement.node(
-        definitions, ElementKind.VARIABLE_LIST, resolver.context.element);
+        definitions, ElementKind.VARIABLE_LIST, resolver.scope.element);
   }
 
   SourceString visitSendSet(SendSet node) {
     assert(node.arguments.tail.isEmpty()); // Sanity check
     resolver.visit(node.arguments.head);
     return visit(node.selector);
   }
 
   SourceString visitIdentifier(Identifier node) => node.source;
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
       SourceString name = visit(link.head);
       VariableElement element = new VariableElement(
-          name, variables, kind, resolver.context.element, node: link.head);
+          name, variables, kind, resolver.scope.element, node: link.head);
       resolver.defineElement(link.head, element);
     }
   }
 }
 
+/**
+ * [SignatureResolver] resolves function signatures.
+ */
 class SignatureResolver extends CommonResolverVisitor<Element> {
   final Element enclosingElement;
   Link<Element> optionalParameters = const EmptyLink<Element>();
   int optionalParameterCount = 0;
-  Node currentDefinitions;
+  VariableDefinitions currentDefinitions;
 
   SignatureResolver(Compiler compiler, this.enclosingElement) : super(compiler);
 
   Element visitNodeList(NodeList node) {
     // This must be a list of optional arguments.
     if (node.beginToken.stringValue !== '[') {
       internalError(node, "expected optional parameters");
     }
     LinkBuilder<Element> elements = analyzeNodes(node.nodes);
     optionalParameterCount = elements.length;
@@ skipping 107 matching lines @@
         // If parameter is null, the current node should be the last,
         // and a list of optional named parameters.
         if (!link.tail.isEmpty() || (link.head is !NodeList)) {
           internalError(link.head, "expected optional parameters");
         }
       }
     }
     return elements;
   }
 
+  /**
+   * Resolves formal parameters and return type to a [FunctionSignature].
+   */
   static FunctionSignature analyze(Compiler compiler,
                                    NodeList formalParameters,
                                    Node returnNode,
                                    Element element) {
     SignatureResolver visitor = new SignatureResolver(compiler, element);
     LinkBuilder<Element> parametersBuilder =
         visitor.analyzeNodes(formalParameters.nodes);
     Link<Element> parameters = parametersBuilder.toLink();
     Type returnType =
         compiler.resolveTypeAnnotation(element, returnNode);
@@ skipping 99 matching lines @@
 
 class Scope {
   final Element element;
   final Scope parent;
 
   Scope(this.parent, this.element);
   abstract Element add(Element element);
   abstract Element lookup(SourceString name);
 }
 
-class TypeVariablesScope extends Scope {
-  TypeVariablesScope(parent, ClassElement element) : super(parent, element);
+class EmptyScope implements Scope {
+  const EmptyScope();
+
+  Element get element() => null;
+
+  Scope get parent() => null;
+
+  Element add(Element element) {
+    throw "Cannot add element to EmptyScope";
+  }
+
+  Element lookup(SourceString name) => null;
+}
+
+/**
+ * [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 {
+  TypeDeclarationElement get element() => super.element;
+
+  TypeDeclarationScope(parent, TypeDeclarationElement element)
+      : super(parent, element);
+
   Element add(Element newElement) {
-    throw "Cannot add element to TypeVariableScope";
+    throw "Cannot add element to TypeDeclarationScope";
   }
+
   Element lookup(SourceString name) {
-    ClassElement cls = element;
-    Element result = cls.lookupTypeParameter(name);
+    Element result = lookupTypeVariable(element, name);
     if (result !== null) return result;
     if (parent !== null) return parent.lookup(name);
   }
+
+  String toString() =>
+      '$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>();
 
   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];
     }
     elements[newElement.name] = newElement;
     return newElement;
   }
+
+  String toString() => '$element${elements.getKeys()} > $parent';
 }
 
 class BlockScope extends MethodScope {
   BlockScope(Scope parent) : super(parent, parent.element);
+
+  String toString() => 'block${elements.getKeys()} > $parent';
 }
 
-class ClassScope extends Scope {
-  ClassScope(ClassElement element, LibraryElement library)
-    : super(new TopScope(library), element);
+/**
+ * [ClassScope] defines the inner scope of a class/interface declaration in
+ * which declared members, declared type variables, entities in the enclosing
+ * scope and inherited members are available, in the given order.
+ */
+class ClassScope extends TypeDeclarationScope {
+  ClassScope(Scope parentScope, ClassElement element)
+      : super(parentScope, element);
 
   Element lookup(SourceString name) {
     ClassElement cls = element;
     Element result = cls.lookupLocalMember(name);
     if (result !== null) return result;
-    result = cls.lookupTypeParameter(name);
-    if (result !== null) return result;
-    result = parent.lookup(name);
+    result = super.lookup(name);
     if (result != null) return result;
     return cls.lookupSuperMember(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in a class scope";
   }
+
+  String toString() => '$element > $parent';
 }
 
 class TopScope extends Scope {
   LibraryElement get library() => element;
 
   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';
 }