Bring type variables into static scope, but produce compile-time error when they are used.

lib/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', prefix: 'api_e');
@@ skipping 85 matching lines @@
     const ElementKind('prefix', ElementCategory.PREFIX);
   static const ElementKind TYPEDEF =
     const ElementKind('typedef', ElementCategory.ALIAS);
 
   static const ElementKind STATEMENT =
     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 MALFORMED_TYPE =
+    const ElementKind('malformed', ElementCategory.NONE);
 
   toString() => id;
 }
 
 class Element implements Spannable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
   Link<MetadataAnnotation> metadata = const EmptyLink<MetadataAnnotation>();
 
@@ skipping 209 matching lines @@
     }
   }
 
   bool _isNative = false;
   void setNative() { _isNative = true; }
   bool isNative() => _isNative;
 
   FunctionElement asFunctionElement() => null;
 
   static bool isInvalid(Element e) => e == null || e.isErroneous();
+
+  bool inStaticContext() {
+    return modifiers.isStatic();
+  }
 }
 
 /**
  * Represents an unresolvable or duplicated element.
  *
  * An [ErroneousElement] is used instead of [null] to provide additional
  * information about the error that caused the element to be unresolvable
  * or otherwise invalid.
  *
  * Accessing any field or calling any method defined on [ErroneousElement]
@@ skipping 869 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 type;
+  MalformedTypeElement(this.type, Element enclosing)
+      : super(const SourceString('malformed'),
+              ElementKind.MALFORMED_TYPE,
+              enclosing);
+  DartType computeType(compiler) => compiler.types.malformedType;
+  Node parseNode(DiagnosticListener dl) => type;
+  bool impliesType() => 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 679 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }