Fix resolution of type parameters in static context, and the use of type parameters in closures.

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);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 953 matching lines @@
       // When the element is a field, we are actually resolving its
       // initial value, which should not have access to instance
       // fields.
       inInstanceContext = (element.isInstanceMember() && !element.isField())
           || element.isGenerativeConstructor(),
       this.currentClass = element.isMember() ?
                               element.getEnclosingClass() :
                               null,
       this.statementScope = new StatementScope(),
       typeResolver = new TypeResolver(compiler),
-      scope = element.buildEnclosingScope(),
+      scope = element.buildScope(),
       super(compiler) {
   }
 
   Enqueuer get world => compiler.enqueuer.resolution;
 
   Element lookup(Node node, SourceString name) {
     Element result = scope.lookup(name);
     if (!inInstanceContext && result != null && result.isInstanceMember()) {
       error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
     }
@@ skipping 76 matching lines @@
 
   DartType useType(TypeAnnotation annotation, DartType type) {
     if (type !== null) {
       mapping.setType(annotation, type);
       useElement(annotation, type.element);
     }
     return type;
   }
 
   void setupFunction(FunctionExpression node, FunctionElement function) {
-    scope = new MethodScope(scope, function);
+    // If [function] is the [enclosingElement], the [scope] has
+    // already been set in the constructor of [ResolverVisitor].
+    if (function != enclosingElement) scope = new MethodScope(scope, function);
+
     // Put the parameters in scope.
     FunctionSignature functionParameters =
         function.computeSignature(compiler);
     Link<Node> parameterNodes = (node.parameters === null)
         ? const EmptyLink<Node>() : node.parameters.nodes;
     functionParameters.forEachParameter((Element element) {
       if (element == functionParameters.optionalParameters.head) {
         NodeList nodes = parameterNodes.head;
         parameterNodes = nodes.nodes;
       }
@@ skipping 1471 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 VariableScope extends Scope {
+  VariableScope(parent, element) : super(parent, element);
+
+  Element add(Element newElement) {
+    throw "Cannot add element to VariableScope";
+  }
+
+  Element lookup(SourceString name) => parent.lookup(name);
+
+  String toString() => '$element > $parent';
+}
+
 /**
  * [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) {
     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) {
     Link<DartType> typeVariableLink = element.typeVariables;
     while (!typeVariableLink.isEmpty()) {
       TypeVariableType typeVariable = typeVariableLink.head;
       if (typeVariable.name == name) {
         return typeVariable.element;
       }
       typeVariableLink = typeVariableLink.tail;
     }
 
@@ skipping 35 matching lines @@
 
   String toString() => 'block${elements.getKeys()} > $parent';
 }
 
 /**
  * [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 {
+  bool inStaticContext = false;
+
   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 = super.lookup(name);
+    if (!inStaticContext) {
+      // If not in a static context, we can lookup in the
+      // TypeDeclaration scope, which contains the type variables of
+      // the class.
+      result = super.lookup(name);
+    } else {
+      result = parent.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';
 }