Refactor scope handling.

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 317 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();
     }
-    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,
+            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) {
@@ skipping 14 matching lines @@
     whenResolved(node, type);
     return type;
   }
 }
 
 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);
-    }
   }
 
   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 47 matching lines @@
     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);
     // 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;
       }
       VariableDefinitions variableDefinitions = parameterNodes.head;
@@ skipping 15 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 56 matching lines @@
   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;
+  Scope scope;
   ClassElement classElement;
 
-  ClassResolverVisitor(Compiler compiler, LibraryElement library,
-                       ClassElement this.classElement)
-    : context = new TopScope(library),
-      super(compiler);
+  ClassResolverVisitor(Compiler compiler,
+                       ClassElement classElement)
+      : this.classElement = classElement,
+        scope = classElement.buildEnclosingScope(),
+        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);
+      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) {
@@ skipping 46 matching lines @@
     calculateAllSupertypes(classElement, new Set<ClassElement>());
     addDefaultConstructorIfNeeded(classElement);
     return classElement.computeType(compiler);
   }
 
   Type visitTypeAnnotation(TypeAnnotation node) {
     return visit(node.typeName);
   }
 
   Type visitIdentifier(Identifier node) {
-    Element element = context.lookup(node.source);
+    Element element = scope.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);
+    Element element = scope.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;
@@ skipping 92 matching lines @@
   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);
+/**
+ * [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;
+
+  TypeDeclarationScope(Scope parent, ClassElement 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 = element.lookupTypeParameter(name);
     if (result !== null) return result;
     if (parent !== null) return parent.lookup(name);
   }
+
+  String toString() =>
+      '$element${element.typeParameters.getKeys()} > $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';
 }