Add TypeVariable object on runtime to support reflection on type variables.

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 get currentElement;
   Set<Node> get superUses;
 
@@ skipping 510 matching lines @@
   DartType resolveReturnType(Element element, TypeAnnotation annotation) {
     if (annotation == null) return compiler.types.dynamicType;
     DartType result = visitorFor(element).resolveTypeAnnotation(annotation);
     if (result == null) {
       // TODO(karklose): warning.
       return compiler.types.dynamicType;
     }
     return result;
   }
 
-  void resolveRedirectionChain(FunctionElement constructor, Node node) {
+  void resolveRedirectionChain(FunctionElement constructor, Spannable node) {
     FunctionElementX current = constructor;
     List<Element> seen = new List<Element>();
     // Follow the chain of redirections and check for cycles.
     while (current != current.defaultImplementation) {
       if (current.internalRedirectionTarget != null) {
         // We found a constructor that already has been processed.
         current = current.internalRedirectionTarget;
         break;
       }
       Element target = current.defaultImplementation;
@@ skipping 532 matching lines @@
       node.accept(visitor);
       annotation.value = compiler.constantHandler.compileNodeWithDefinitions(
           node, visitor.mapping, isConst: true);
       compiler.backend.registerMetadataConstant(annotation.value,
                                                 visitor.mapping);
 
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
-  error(Node node, MessageKind kind, [arguments = const {}]) {
+  error(Spannable node, MessageKind kind, [arguments = const {}]) {
     // TODO(ahe): Make non-fatal.
     compiler.reportFatalError(node, kind, arguments);
   }
 }
 
 class ConstantMapper extends Visitor {
   final Map<Constant, Node> constantToNodeMap = new Map<Constant, Node>();
   final CompileTimeConstantEvaluator evaluator;
 
   ConstantMapper(ConstantHandler handler,
@@ skipping 3425 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, SourceString name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }