Handle type variable in static member.

lib/compiler/implementation/resolution/members.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(Node node);
   bool isParameterChecked(Element element);
 }
@@ skipping 330 matching lines @@
       // the error message below.
       error(node,
             MessageKind.CANNOT_FIND_CONSTRUCTOR2,
             [selector.name, defaultClass.name]);
     }
   }
 
   TreeElements resolveField(VariableElement element) {
     Node tree = element.parseNode(compiler);
     if(element.modifiers.isStatic() && element.variables.isTopLevel()) {
-      error(element.modifiers.getStatic(), MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
+      error(element.modifiers.getStatic(),
+            MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
     }
     ResolverVisitor visitor = new ResolverVisitor(compiler, element);
     initializerDo(tree, visitor.visit);
     return visitor.mapping;
   }
 
   TreeElements resolveParameter(Element element) {
     Node tree = element.parseNode(compiler);
     ResolverVisitor visitor =
         new ResolverVisitor(compiler, element.enclosingElement);
@@ skipping 716 matching lines @@
       }
     } else {
       return scope.lookup(typeName.source);
     }
   }
 
   // TODO(johnniwinther): Change  [onFailure] and [whenResolved] to use boolean
   // flags instead of closures.
   // TODO(johnniwinther): Should never return [null] but instead an erroneous
   // type.
-  DartType resolveTypeAnnotation(TypeAnnotation node,
-                                 {Scope inScope, ClassElement inClass,
-                                 onFailure(Node, MessageKind, [List arguments]),
-                                 whenResolved(Node, Type)}) {
+  DartType resolveTypeAnnotation(
+      TypeAnnotation node,
+      Scope scope,
+      {onFailure(Node node, MessageKind kind, [List arguments]),
+       whenResolved(Node node, DartType type)}) {
     if (onFailure == null) {
       onFailure = (n, k, [arguments]) {};
     }
     if (whenResolved == null) {
       whenResolved = (n, t) {};
     }
-    if (inClass != null) {
-      inScope = inClass.buildScope();
-    }
-    if (inScope == null) {
+    if (scope == null) {
       compiler.internalError('resolveTypeAnnotation: no scope specified');
     }
-    return resolveTypeAnnotationInContext(inScope, node, onFailure,
+    return resolveTypeAnnotationInContext(scope, node, onFailure,
                                           whenResolved);
   }
 
   DartType resolveTypeAnnotationInContext(Scope scope, TypeAnnotation node,
                                           onFailure, whenResolved) {
     Element element = resolveTypeName(scope, node);
     DartType type;
     if (element == null) {
       onFailure(node, MessageKind.CANNOT_RESOLVE_TYPE, [node.typeName]);
     } else if (element.isErroneous()) {
@@ skipping 838 matching lines @@
           argument.element.enclosingElement);
     } else if (argument is InterfaceType) {
       InterfaceType type = argument;
       type.arguments.forEach((DartType argument) {
         analyzeTypeArgument(type, argument);
       });
     }
   }
 
   DartType resolveTypeAnnotation(TypeAnnotation node) {
+    // TODO(johnniwinther): Remove this together with the named arguments
+    // on [TypeResolver.resolveTypeAnnotation].
+    void checkAndUseType(TypeAnnotation annotation, DartType type) {
+      useType(annotation, type);
+      if (type != null &&
+          identical(type.kind, TypeKind.TYPE_VARIABLE) &&
+          enclosingElement.isInStaticMember()) {
+        warning(annotation, MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
+                [type]);
+      }
+    }
+
     Function report = typeRequired ? error : warning;
-    DartType type = typeResolver.resolveTypeAnnotation(node, inScope: scope,
-                                                       onFailure: report,
-                                                       whenResolved: useType);
+    DartType type = typeResolver.resolveTypeAnnotation(
+        node, scope, onFailure: report, whenResolved: checkAndUseType);
     if (type == null) return null;
     if (inCheckContext) {
       compiler.enqueuer.resolution.registerIsCheck(type);
     }
     if (typeRequired || inCheckContext) {
       if (type is InterfaceType) {
         InterfaceType itf = type;
         itf.arguments.forEach((DartType argument) {
           analyzeTypeArgument(type, argument);
         });
@@ skipping 334 matching lines @@
       SourceString typeName = typeVariable.name;
       TypeVariable typeNode = nodeLink.head;
       if (nameSet.contains(typeName)) {
         error(typeNode, MessageKind.DUPLICATE_TYPE_VARIABLE_NAME, [typeName]);
       }
       nameSet.add(typeName);
 
       TypeVariableElement variableElement = typeVariable.element;
       if (typeNode.bound != null) {
         DartType boundType = typeResolver.resolveTypeAnnotation(
-            typeNode.bound, inScope: scope, onFailure: warning);
+            typeNode.bound, scope, onFailure: warning);
         if (boundType != null && boundType.element == variableElement) {
           // TODO(johnniwinther): Check for more general cycles, like
           // [: <A extends B, B extends C, C extends B> :].
           warning(node, MessageKind.CYCLIC_TYPE_VARIABLE,
                   [variableElement.name]);
         } else if (boundType != null) {
           variableElement.bound = boundType;
         } else {
           // TODO(johnniwinther): Should be an erroneous type.
           variableElement.bound = compiler.objectClass.computeType(compiler);
@@ skipping 632 matching lines @@
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF, [name]);
     } else if (identical(e.kind, ElementKind.TYPE_VARIABLE)) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE, [name]);
     } else if (!identical(e.kind, ElementKind.CLASS)
         && !identical(e.kind, ElementKind.PREFIX)) {
       error(node, MessageKind.NOT_A_TYPE, [name]);
     }
     return e;
   }
 }