Produce run-time error when type parameters are accessed from static context.

sdk/lib/_internal/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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 1063 matching lines @@
     }
   }
 
   // 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 scope,
+      bool inStaticContext,
       {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 (scope == null) {
       compiler.internalError('resolveTypeAnnotation: no scope specified');
     }
-    return resolveTypeAnnotationInContext(scope, node, onFailure,
-                                          whenResolved);
+    return resolveTypeAnnotationInContext(scope, node, inStaticContext,
+        onFailure, whenResolved);
   }
 
   DartType resolveTypeAnnotationInContext(Scope scope, TypeAnnotation node,
+                                          bool inStaticContext,
                                           onFailure, whenResolved) {
     Element element = resolveTypeName(scope, node);
     DartType type;
     if (element == null) {
       onFailure(node, MessageKind.CANNOT_RESOLVE_TYPE, [node.typeName]);
     } else if (element.isAmbiguous()) {
       AmbiguousElement ambiguous = element;
       onFailure(node, ambiguous.messageKind, ambiguous.messageArguments);
     } else if (!element.impliesType()) {
       onFailure(node, MessageKind.NOT_A_TYPE, [node.typeName]);
     } else {
       if (identical(element, compiler.types.voidType.element) ||
           identical(element, compiler.types.dynamicType.element)) {
         type = element.computeType(compiler);
       } else if (element.isClass()) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
         Link<DartType> arguments =
-            resolveTypeArguments(node, cls.typeVariables, scope,
+            resolveTypeArguments(node, cls.typeVariables,
+                                 inStaticContext, 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);
+          // Bubble-up malformed-ness of the type.
+          bool isMalformedType = false;
+          for (Link<DartType> link = arguments;
+              !link.isEmpty;
+              link = link.tail) {
+            DartType dtype = link.head;
+            if (dtype is MalformedType) {
+              isMalformedType = true;
+              break;
+            }
+          }

[ahe, 2012/11/22 12:41:30]

This for loop is a great candidate for a helper method.

[aam-me, 2012/11/23 02:16:47]

Done.

+          if (isMalformedType) {
+            type = new MalformedType(
+                new MalformedTypeElement(node, 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,
+            node, typdef.typeVariables, inStaticContext,
             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 (inStaticContext) {
+          ResolutionWarning warning =
+              new ResolutionWarning(MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,

[ahe, 2012/11/22 12:41:30]

Long line.

[aam-me, 2012/11/23 02:16:47]

Done.

+                                    [element]);
+          compiler.reportWarning(node, warning);
+          type = new MalformedType(new MalformedTypeElement(node, 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,
                                       Link<DartType> typeVariables,
+                                      bool inStaticContext,
                                       Scope scope, onFailure, whenResolved) {
     if (node.typeArguments == null) {
       return const Link<DartType>();
     }
     var arguments = new LinkBuilder<DartType>();
     for (Link<Node> typeArguments = node.typeArguments.nodes;
          !typeArguments.isEmpty;
          typeArguments = typeArguments.tail) {
       if (typeVariables.isEmpty) {
         onFailure(typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
       }
       DartType argType = resolveTypeAnnotationInContext(scope,
                                                     typeArguments.head,
+                                                    inStaticContext,
                                                     onFailure,
                                                     whenResolved);
       arguments.addLast(argType);
       if (!typeVariables.isEmpty) {
         typeVariables = typeVariables.tail;
       }
     }
     if (!typeVariables.isEmpty) {
       onFailure(node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
     }
@@ skipping 878 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, scope, onFailure: report, whenResolved: checkAndUseType);
+        node, scope, enclosingElement.isInStaticMember(),
+        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) {
           analyzeTypeArgument(type, argument);
         });
@@ skipping 346 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, scope, onFailure: warning);
+            typeNode.bound, scope, element.isInStaticMember(),
+            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 667 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }