Bring type variables into static scope, but produce compile-time error when they are used.

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.
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 1112 matching lines @@
     return element;
   }
 
   Element useElement(Node node, Element element) {
     if (element === null) return null;
     return mapping[node] = element;
   }
 
   DartType useType(TypeAnnotation annotation, DartType type) {
     if (type !== null) {
+      if (type.element.isTypeVariable() && enclosingElement.inStaticContext()) {
+        error(annotation,
+              MessageKind.CANNOT_ACCESS_TYPE_VARIABLE_IN_STATIC_CONTEXT,
+              [type.name]);
+      }
       mapping.setType(annotation, type);
       useElement(annotation, type.element);
     }
     return type;
   }
 
   void setupFunction(FunctionExpression node, FunctionElement 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);
@@ skipping 1610 matching lines @@
 
   Element lexicalLookup(SourceString name) {
     Element result = localLookup(name);
     if (result != null) return result;
     return parent.lexicalLookup(name);
   }
 
   abstract Element localLookup(SourceString name);
 }
 
 class VariableScope extends Scope {

[ahe, 2012/10/02 07:50:25]

I think we should get rid of this one as well.

[Johnni Winther, 2012/10/02 09:07:30]

I agree. Remove this class.

[aam-me, 2012/10/02 12:50:39]

Thanks, done!

   VariableScope(parent, element) : super(parent, element);
 
   Element add(Element newElement) {
     throw "Cannot add element to VariableScope";
   }
 
   Element localLookup(SourceString name) => null;
 
   String toString() => '$element > $parent';
 }
@@ skipping 60 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;

[ahe, 2012/10/02 07:50:25]

This is great.

-
   ClassScope(Scope parentScope, ClassElement element)
       : super(parentScope, element);
 
   Element localLookup(SourceString name) {
     ClassElement cls = element;
     Element result = cls.lookupLocalMember(name);
     if (result !== null) return result;
-    if (!inStaticContext) {
-      // If not in a static context, we can lookup in the
-      // TypeDeclaration scope, which contains the type variables of
-      // the class.
-      return super.localLookup(name);
-    }
-    return null;
+    return super.localLookup(name);
   }
 
   Element lookup(SourceString name) {
     Element result = super.lookup(name);
     if (result !== null) return result;
     ClassElement cls = element;
     return cls.lookupSuperMember(name);
   }
 
   Element add(Element newElement) {
@@ skipping 10 matching lines @@
 
   Element localLookup(SourceString name) => library.find(name);
   Element lookup(SourceString name) => localLookup(name);
   Element lexicalLookup(SourceString name) => localLookup(name);
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }