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

sdk/lib/_internal/compiler/implementation/elements/elements.dart

Index: sdk/lib/_internal/compiler/implementation/elements/elements.dart
diff --git a/sdk/lib/_internal/compiler/implementation/elements/elements.dart b/sdk/lib/_internal/compiler/implementation/elements/elements.dart
index e322c4ee1e1e5d5e7b3025e522c0975c218f8c78..2a68ad8e6918bcec87e96005c49d9dbe5c753e8a 100644
--- a/sdk/lib/_internal/compiler/implementation/elements/elements.dart
+++ b/sdk/lib/_internal/compiler/implementation/elements/elements.dart
@@ -120,6 +120,8 @@ class ElementKind {
       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;
 }
@@ -200,6 +202,8 @@ class Element implements Spannable {
   /** See [AmbiguousElement] for documentation. */
   bool isAmbiguous() => false;
 
+  bool isMalformed() => false;
+
   /**
    * Is [:true:] if this element has a corresponding patch.
    *
@@ -1319,6 +1323,19 @@ class VoidElement extends Element {
   bool impliesType() => true;
 }
 
+class MalformedTypeElement extends Element {
+  final TypeAnnotation type;

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

This is an ast node.  Do we assume that enclosing is an element whose
compilation-unit contains this node?

Generally, I would like to avoid having a field called "type" that isn't a
DartType.  How about renaming this to typeNode?

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

Separate field from constructor with a new line.

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

Currently in both cases when MalformedTypEelement is created enclosing element
is result of type name resolution of this given type(typeNode). Not sure what is
definition of compilation-unit, but I think it is possible to get type from some
other library resolved into element from that other library(which is different
compilation unit, right?).
For the purposes of type parameter name resolution(which is what
MalformedTypeElement is currently used for) I think type parameter name can only
come current compilation unit.

What is the concern for situation when element's compilation-unit doesn't
contain the node?

[ahe, 2012/11/23 06:16:13]

All AST nodes and tokens record a character offset from the beginning of the
current file.  However, they don't know what the current file is.  This is
recorded by the element (via its reference to a compilation unit).

[aam-me, 2012/11/23 14:02:27]

I see. In our case "enclosing" is either class element which has type variable
reference or the type variable reference itself(element.isTypeVariable()). In
both cases I believe element and node are part of the same compilation unit.

[ahe, 2012/11/23 15:26:10]

That makes sense.  But we have to watch out for Johnni who might extend this
class to other situations.  He may break that invariant :-)

+  MalformedTypeElement(this.type, Element enclosing)
+      : super(const SourceString('malformed'),
+              ElementKind.MALFORMED_TYPE,
+              enclosing);

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

Add newline.

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

Done.

+  DartType computeType(compiler) => compiler.types.malformedType;

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

Ditto.

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

Done.

+  Node parseNode(_) => type;

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

Ditto.

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

Done.

+  bool impliesType() => true;
+
+  bool isMalformed() => true;
+}
+
 /**
  * [TypeDeclarationElement] defines the common interface for class/interface
  * declarations and typedefs.
@@ -1724,8 +1741,9 @@ abstract class ClassElement extends ScopeContainerElement
 }
 
 class Elements {
-  static bool isUnresolved(Element e) => e == null || e.isErroneous();
+  static bool isUnresolved(Element e) => e == null || e.isErroneous() || e.isMalformed();

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

Long line.  As a matter of style, I then prefer to move to the longer syntax,
that is, { return ... }.

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

Done.

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