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 1031 matching lines @@
       } else if (element.isClass()) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
         Link<DartType> 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);
+          bool isMalformedType = false;
+          for (Link<DartType> link = arguments;
+              !link.isEmpty();
+              link = link.tail) {
+            DartType dtype = link.head;

[karlklose, 2012/10/10 07:19:33]

dtype -> type. (The class is only called DartType because there already is a
class called type in the core library.)

+            if (dtype is MalformedType) {
+              isMalformedType = true;
+              break;
+            }
+          }
+          if (isMalformedType) {
+            type = new MalformedType(
+                new MalformedTypeElement(node, scope.element));
+          } else {
+            type = new InterfaceType(cls, arguments);
+          }
         }
       } else if (element.isTypedef()) {
         TypedefElement typdef = element;
         // TODO(ahe): Should be [ensureResolved].
         compiler.resolveTypedef(typdef);
         typdef.computeType(compiler);
         Link<DartType> arguments = resolveTypeArguments(
             node, typdef.typeVariables,
             scope, onFailure, whenResolved);
         if (typdef.typeVariables.isEmpty() && arguments.isEmpty()) {
           // Return the canonical type if it has no type parameters.
           type = typdef.computeType(compiler);
         } else {
           type = new TypedefType(typdef, arguments);
         }
       } else if (element.isTypeVariable()) {
-        type = element.computeType(compiler);
+        if (scope.inStaticContext) {
+          onFailure(node, MessageKind.CANNOT_ACCESS_TYPE_VARIABLE_IN_STATIC_CONTEXT, [element.name]);

[karlklose, 2012/10/10 07:19:33]

Long line.

+          type = new MalformedType(
+              new MalformedTypeElement(node, scope.element));
+        } else  {
+          type = element.computeType(compiler);
+        }
       } else {
         compiler.cancel("unexpected element kind ${element.kind}",
                         node: node);
       }
     }
     whenResolved(node, type);
     return type;
   }
 
   Link<DartType> resolveTypeArguments(TypeAnnotation node,
@@ skipping 1795 matching lines @@
     } else if (e.kind !== ElementKind.CLASS && e.kind !== ElementKind.PREFIX) {
       error(node, MessageKind.NOT_A_TYPE, [name]);
     }
     return e;
   }
 }
 
 abstract class Scope {
   final Element element;
   final Scope parent;
+  bool get inStaticContext => false;
 
   Scope(this.parent, this.element);
   abstract Element add(Element element);
 
   Element lookup(SourceString name) {
     Element result = localLookup(name);
     if (result != null) return result;
     return parent.lookup(name);
   }
 
   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 {
   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';
+
+  bool get inStaticContext => element.inStaticContext();//parent.inStaticContext();

[karlklose, 2012/10/10 07:19:33]

Remove code in comment.

 }
 
 /**
  * [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 {
@@ skipping 37 matching lines @@
 
   Element add(Element newElement) {
     if (elements.containsKey(newElement.name)) {
       return elements[newElement.name];
     }
     elements[newElement.name] = newElement;
     return newElement;
   }
 
   String toString() => '$element${elements.getKeys()}';
+
+  bool get inStaticContext => parent.inStaticContext;
 }
 
 class BlockScope extends MethodScope {
   BlockScope(Scope parent) : super(parent, parent.element);
 
   String toString() => 'block${elements.getKeys()}';
 }
 
 /**
  * [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)  {
     assert(parent !== null);
   }
 
   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.
-      result = super.localLookup(name);
-    }
+    result = super.localLookup(name);
     return result;
   }
 
   Element lookup(SourceString name) {
     Element result = localLookup(name);
     if (result !== null) return result;
     result = parent.lookup(name);
     if (result !== null) return result;
     ClassElement cls = element;
     return cls.lookupSuperMember(name);
@@ skipping 16 matching lines @@
                   ClassElement origin, ClassElement this.patch)
       : super(parentScope, origin) {
     assert(parent !== null);
   }
 
   Element localLookup(SourceString name) {
     Element result = patch.lookupLocalMember(name);
     if (result !== null) return result;
     result = origin.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.
-      result = super.localLookup(name);
-      if (result !== null) return result;
-    }
+    result = super.localLookup(name);
+    if (result !== null) return result;
     result = parent.lookup(name);
     if (result !== null) return result;
     return result;
   }
 
   Element lookup(SourceString name) {
     Element result = localLookup(name);
     if (result !== null) return result;
     // TODO(johnniwinther): Should we support patch lookup on supertypes?
     return origin.lookupSuperMember(name);
@@ skipping 81 matching lines @@
     return result;
   }
   Element lookup(SourceString name) => localLookup(name);
   Element lexicalLookup(SourceString name) => localLookup(name);
 
   Element add(Element newElement) {
     throw "Cannot add an element in a patch library scope";
   }
   String toString() => 'PatchLibraryScope($origin,$patch)';
 }