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

sdk/lib/_internal/compiler/implementation/elements/elements.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.
 
 library elements;
 
 import 'dart:uri';
 
 // TODO(ahe): Rename prefix to 'api' when VM bug is fixed.
 import '../../compiler.dart' as api_e;
@@ skipping 102 matching lines @@
     const ElementKind('statement', ElementCategory.NONE);
   static const ElementKind LABEL =
     const ElementKind('label', ElementCategory.NONE);
   static const ElementKind VOID =
     const ElementKind('void', ElementCategory.NONE);
 
   static const ElementKind AMBIGUOUS =
       const ElementKind('ambiguous', ElementCategory.NONE);
   static const ElementKind ERROR =
       const ElementKind('error', ElementCategory.NONE);
+  static const ElementKind MALFORMED_TYPE =
+    const ElementKind('malformed', ElementCategory.NONE);
 
   toString() => id;
 }
 
 class Element implements Spannable {
   static int elementHashCode = 0;
 
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
@@ skipping 60 matching lines @@
   bool isLibrary() => identical(kind, ElementKind.LIBRARY);
   bool impliesType() => (kind.category & ElementCategory.IMPLIES_TYPE) != 0;
   bool isExtendable() => (kind.category & ElementCategory.IS_EXTENDABLE) != 0;
 
   /** See [ErroneousElement] for documentation. */
   bool isErroneous() => false;
 
   /** See [AmbiguousElement] for documentation. */
   bool isAmbiguous() => false;
 
+  bool isMalformed() => false;
+
   /**
    * Is [:true:] if this element has a corresponding patch.
    *
    * If [:true:] this element has a non-null [patch] field.
    *
    * See [:patch_parser.dart:] for a description of the terminology.
    */
   bool get isPatched => false;
 
   /**
@@ skipping 1099 matching lines @@
 class VoidElement extends Element {
   VoidElement(Element enclosing)
       : super(const SourceString('void'), ElementKind.VOID, enclosing);
   DartType computeType(compiler) => compiler.types.voidType;
   Node parseNode(_) {
     throw 'internal error: parseNode on void';
   }
   bool impliesType() => true;
 }
 
+class MalformedTypeElement extends Element {
+  final TypeAnnotation typeNode;
+
+  MalformedTypeElement(this.typeNode, Element enclosing)
+      : super(const SourceString('malformed'),
+              ElementKind.MALFORMED_TYPE,
+              enclosing);
+
+  DartType computeType(compiler) => compiler.types.malformedType;
+
+  Node parseNode(_) => typeNode;
+
+  bool impliesType() => true;
+
+  bool isMalformed() => true;
+}
+
 /**
  * [TypeDeclarationElement] defines the common interface for class/interface
  * declarations and typedefs.
  */
 abstract class TypeDeclarationElement implements Element {
   // TODO(johnniwinther): This class should eventually be a mixin.
 
   /**
    * The type variables declared on this declaration. The type variables are not
    * available until the type of the element has been computed through
@@ skipping 385 matching lines @@
       return 'patch ${super.toString()}';
     } else if (patch != null) {
       return 'origin ${super.toString()}';
     } else {
       return super.toString();
     }
   }
 }
 
 class Elements {
-  static bool isUnresolved(Element e) => e == null || e.isErroneous();
+  static bool isUnresolved(Element e) {
+    return e == null || e.isErroneous() || e.isMalformed();
+  }
   static bool isErroneousElement(Element e) => e != null && e.isErroneous();
+  static bool isMalformedElement(Element e) => e != null && e.isMalformed();
 
   static bool isClass(Element e) => e != null && e.kind == ElementKind.CLASS;
   static bool isTypedef(Element e) {
     return e != null && e.kind == ElementKind.TYPEDEF;
   }
 
   static bool isLocal(Element element) {
     return !Elements.isUnresolved(element)
             && !element.isInstanceMember()
             && !isStaticOrTopLevelField(element)
@@ skipping 312 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }