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 1020 matching lines @@
     breakTargetStack = breakTargetStack.tail;
     labels = labels.outer;
   }
 }
 
 class TypeResolver {
   final Compiler compiler;
 
   TypeResolver(this.compiler);
 
+  bool anyMalformedTypesInThere(Link<DartType> list) {

[ngeoffray, 2012/11/27 09:37:35]

Personal taste, but I would remove 'InThere'.

[aam-me, 2012/11/28 01:49:47]

I understand. No objections to this.

+    for (Link<DartType> link = list;
+        !link.isEmpty;
+        link = link.tail) {
+      DartType dtype = link.head;
+      if (dtype is MalformedType) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   Element resolveTypeName(Scope scope, TypeAnnotation node) {
     Identifier typeName = node.typeName.asIdentifier();
     Send send = node.typeName.asSend();
     return resolveTypeNameInternal(scope, typeName, send);
   }
 
   Element resolveTypeNameInternal(Scope scope, Identifier typeName, Send send) {
     if (send != null) {
       typeName = send.selector;
     }
@@ skipping 23 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.declaration, arguments);
+          // In checked mode malformed-ness of the type argument bubbles up.

[ngeoffray, 2012/11/27 09:37:35]

Why not in non-checked mode? Is that an optimization because codegen does not
need it? For robutsness sake, I would still bubble it up in all cases.

[aam-me, 2012/11/28 01:49:47]

When we produce MalformedTypeElement here, it triggers runtime exception
generation in builder in codegen phase. We don't want to have runtime exception
in production mode.

[ahe, 2012/11/28 02:08:50]

I think what Nicolas is saying is that we generally try to keep resolution
independent of production mode or not. There are some long term benefits to
this, and short term, the benefits would be that our source mirror API always
behave the same.

So ideally, we would let the backend decide how to handle a malformed type,
depending on the mode. 

+          if (anyMalformedTypesInThere(arguments) &&
+              compiler.enableTypeAssertions) {
+            type = new MalformedType(
+                new MalformedTypeElement(node, element));
+          } else {
+            type = new InterfaceType(cls.declaration, 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) {
+          compiler.reportWarning(node,
+              MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER.message(
+                  [element]));
+          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 874 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);
   }
 }