Implement type argument access and reification of runtime types.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart

 // Copyright (c) 2013, 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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
 import '../cps_ir/optimizers.dart';
-import '../dart_types.dart' show DartType, GenericType;
+import '../dart_types.dart' show DartType, GenericType, TypeVariableType;
 import '../dart2jslib.dart' as dart2js show
     CURRENT_ELEMENT_SPANNABLE,
     InternalErrorFunction,
     invariant;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
 import '../universe/universe.dart' show Selector, SelectorKind;
 
 abstract class Node {
   /// A pointer to the parent node. Is null until set by optimization passes.
@@ skipping 616 matching lines @@
 }
 
 class This extends Primitive {
   This();
 
   accept(Visitor visitor) => visitor.visitThis(this);
 }
 
 /// Reify the given type variable as a [Type].
 /// This depends on the current binding of 'this'.
-class ReifyTypeVar extends Primitive {
+class ReifyTypeVar extends Primitive implements DartSpecificNode {
   final TypeVariableElement typeVariable;
 
   ReifyTypeVar(this.typeVariable);
 
   values.ConstantValue get constant => null;
 
   accept(Visitor visitor) => visitor.visitReifyTypeVar(this);
 }
 
 class LiteralList extends Primitive {
@@ skipping 201 matching lines @@
       ConstructorElement element,
       List<Definition> parameters,
       List<ConstantExpression> defaultParameterValues)
       : initializers = null,
         super.abstract(element, parameters, defaultParameterValues);
 
   accept(Visitor visitor) => visitor.visitConstructorDefinition(this);
   applyPass(Pass pass) => pass.rewriteConstructorDefinition(this);
 }
 
+/// Converts the internal representation of a type to a Dart object of type
+/// [Type].
+class ReifyRuntimeType extends Primitive implements JsSpecificNode {
+  /// Reference to the internal representation of a type (as produced, for
+  /// example, by [ReadTypeVariable]).
+  final Reference<Primitive> value;
+  ReifyRuntimeType(Primitive value)
+    : this.value = new Reference<Primitive>(value);
+
+  @override
+  accept(Visitor visitor) => visitor.visitReifyRuntimeType(this);
+}
+
+/// Read the value the type variable [variable] from the target object.
+///
+/// The resulting value is an internal representation (and not neccessarily a
+/// Dart object), and must be reified by [ReifyRuntimeType], if it should be
+/// used as a Dart value.
+class ReadTypeVariable extends Primitive implements JsSpecificNode {
+  final TypeVariableType variable;
+  final Reference<Primitive> target;
+
+  ReadTypeVariable(this.variable, Primitive target)
+      : this.target = new Reference<Primitive>(target);
+
+  @override
+  accept(Visitor visitor) => visitor.visitReadTypeVariable(this);
+}
+
 List<Reference<Primitive>> _referenceList(Iterable<Primitive> definitions) {
   return definitions.map((e) => new Reference<Primitive>(e)).toList();
 }
 
 abstract class Visitor<T> {
   const Visitor();
 
   T visit(Node node);
 
   // Concrete classes.
@@ skipping 27 matching lines @@
   T visitLiteralMap(LiteralMap node);
   T visitConstant(Constant node);
   T visitThis(This node);
   T visitReifyTypeVar(ReifyTypeVar node);
   T visitCreateFunction(CreateFunction node);
   T visitGetMutableVariable(GetMutableVariable node);
   T visitParameter(Parameter node);
   T visitContinuation(Continuation node);
   T visitMutableVariable(MutableVariable node);
 
+  // JavaScript specific nodes.
+
   // Conditions.
   T visitIsTrue(IsTrue node);
 
-  // JavaScript specific nodes.
   // Expressions.
   T visitSetField(SetField node);
+
   // Definitions.
   T visitIdentical(Identical node);
   T visitInterceptor(Interceptor node);
   T visitCreateInstance(CreateInstance node);
   T visitGetField(GetField node);
   T visitCreateBox(CreateBox node);
+  T visitReifyRuntimeType(ReifyRuntimeType node);
+  T visitReadTypeVariable(ReadTypeVariable node);
 }
 
 /// Recursively visits the entire CPS term, and calls abstract `process*`
 /// (i.e. `processLetPrim`) functions in pre-order.
 class RecursiveVisitor implements Visitor {
   const RecursiveVisitor();
 
   visit(Node node) => node.accept(this);
 
   processReference(Reference ref) {}
@@ skipping 240 matching lines @@
   processGetField(GetField node) {}
   visitGetField(GetField node) {
     processGetField(node);
     processReference(node.object);
   }
 
   processCreateBox(CreateBox node) {}
   visitCreateBox(CreateBox node) {
     processCreateBox(node);
   }
+
+  processReifyRuntimeType(ReifyRuntimeType node) {}
+  visitReifyRuntimeType(ReifyRuntimeType node) {
+    processReifyRuntimeType(node);
+    processReference(node.value);
+  }
+
+  processReadTypeVariable(ReadTypeVariable node) {}
+  visitReadTypeVariable(ReadTypeVariable node) {
+    processReadTypeVariable(node);
+    processReference(node.target);
+  }
 }
 
 /// Keeps track of currently unused register indices.
 class RegisterArray {
   int nextIndex = 0;
   final List<int> freeStack = <int>[];
 
   /// Returns an index that is currently unused.
   int makeIndex() {
     if (freeStack.isEmpty) {
@@ skipping 244 matching lines @@
   }
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 
   void visitInterceptor(Interceptor node) {
     visitReference(node.input);
   }
+
+  void visitReifyRuntimeType(ReifyRuntimeType node) {
+    visitReference(node.value);
+  }
+
+  void visitReadTypeVariable(ReadTypeVariable node) {
+    visitReference(node.target);
+  }
 }