Implement type argument access and reification of runtime types.

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

Index: pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart
diff --git a/pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart b/pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart
index 285af06f126558136b9c40b925740a45c0a1c192..48c9361ae554656b01be9490bc3dfd3dd014f085 100644
--- a/pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart
+++ b/pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart
@@ -638,7 +638,7 @@ class This extends Primitive {
 
 /// 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);
@@ -860,6 +860,27 @@ class ConstructorDefinition extends FunctionDefinition {
   applyPass(Pass pass) => pass.rewriteConstructorDefinition(this);
 }
 
+class ReifyRuntimeType extends Primitive implements JsSpecificNode {

[asgerf, 2015/03/02 13:52:36]

Please clarify that [value] should be a "JS type" as produced by
ReadTypeVariable. My first intuition was that you could give it any object and
this would give you back the corresponding Type object.

Likewise clarify at ReadTypeVariable that the result is a "JS type" and not a
Type object.

[karlklose, 2015/03/05 09:54:58]

Done.

[asgerf, 2015/03/05 10:58:07]

Great!

+  final Reference<Primitive> value;
+  ReifyRuntimeType(Primitive value)
+    : this.value = new Reference<Primitive>(value);
+
+  @override
+  accept(Visitor visitor) => visitor.visitReifyRuntimeType(this);
+}
+
+class ReadTypeVariable extends Primitive implements JsSpecificNode {
+  final TypeVariableType variable;
+  final ClassElement context;

[asgerf, 2015/03/02 13:52:36]

Please provide a doc comment for 'context' and for the class itself. 'context'
in particular is a fairly generic name it's not obvious what it means here.

From our discussion last week, I *believe* context is a subclass of the type
that declares [variable], AND a superclass of the runtime type of [target], and
this is the invariant that we use.

Is it correctly understood that any class satisfying the above will work? Will
it generate better code if using a more specific class rather than just the
class declaring [variable]?

From an operational semantics point-of-view, it seems to me that context is
redundant, and we just keep it because it happens to carry some useful static
type information about the other operands. This is fine, but please clarify.

[karlklose, 2015/03/05 09:54:58]

Acknowledged.

+  final Reference<Primitive> target;
+
+  ReadTypeVariable(this.variable, this.context, 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();
 }
@@ -926,6 +947,8 @@ abstract class Visitor<T> {
   // JavaScript specific nodes.
   T visitIdentical(Identical node) => visitPrimitive(node);
   T visitInterceptor(Interceptor node) => visitPrimitive(node);
+  T visitReifyRuntimeType(ReifyRuntimeType node) => visitPrimitive(node);
+  T visitReadTypeVariable(ReadTypeVariable node) => visitPrimitive(node);
 }
 
 /// Recursively visits the entire CPS term, and calls abstract `process*`
@@ -1192,6 +1215,18 @@ abstract class RecursiveVisitor extends Visitor {
   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.
@@ -1443,4 +1478,12 @@ class RegisterAllocator extends Visitor {
   void visitInterceptor(Interceptor node) {
     visitReference(node.input);
   }
+
+  void visitReifyRuntimeType(ReifyRuntimeType node) {
+    visitReference(node.value);
+  }
+
+  void visitReadTypeVariable(ReadTypeVariable node) {
+    visitReference(node.target);
+  }
 }