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(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 1068 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,

[karlklose, 2012/10/19 12:05:38]

Maybe put the first two arguments on their on lines, too?

[Johnni Winther, 2012/10/22 09:03:32]

Done.

+      {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 215 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) {

[karlklose, 2012/10/19 12:05:38]

I think you should rename this helper.

[Johnni Winther, 2012/10/22 09:03:32]

Renamed and doc added.

     if (type != null) {
       mapping.setType(annotation, type);
       useElement(annotation, type.element);
+      if (type is TypeVariableType && enclosingElement.isInStaticMember()) {

[ahe, 2012/10/19 11:58:04]

I would prefer using .kind over is tests. I would like to have a DynamicType
which implements all other types.

[Johnni Winther, 2012/10/22 09:03:32]

TypeKind added.

+        error(annotation, MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
+            [type]);

[karlklose, 2012/10/19 12:05:38]

Indentation is wrong.

[Johnni Winther, 2012/10/22 09:03:32]

Done.

+      }
     }
     return type;
   }
 
   void setupFunction(FunctionExpression node, FunctionElement function) {
     scope = new MethodScope(scope, function);
 
     // Put the parameters in scope.
     FunctionSignature functionParameters =
         function.computeSignature(compiler);
@@ skipping 598 matching lines @@
     } else if (argument is InterfaceType) {
       InterfaceType type = argument;
       type.arguments.forEach((DartType argument) {
         analyzeTypeArgument(type, argument);
       });
     }
   }
 
   DartType resolveTypeAnnotation(TypeAnnotation node) {
     Function report = typeRequired ? error : warning;
-    DartType type = typeResolver.resolveTypeAnnotation(node, inScope: scope,
+    DartType type = typeResolver.resolveTypeAnnotation(node, scope,
                                                        onFailure: report,
                                                        whenResolved: useType);
     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) {
@@ skipping 331 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 865 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)';
 }