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 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.
  */
 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) => 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) {
     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)';
 }