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;
@@ skipping 620 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);
 }
 
+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();
 }
 
 abstract class Visitor<T> {
   const Visitor();
 
   T visit(Node node) => node.accept(this);
   // Abstract classes.
   T visitNode(Node node) => null;
@@ skipping 46 matching lines @@
   T visitGetField(GetField node) => visitDefinition(node);
   T visitCreateBox(CreateBox node) => visitDefinition(node);
   T visitCreateInstance(CreateInstance node) => visitDefinition(node);
 
   // Conditions.
   T visitIsTrue(IsTrue node) => visitCondition(node);
 
   // 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*`
 /// (i.e. `processLetPrim`) functions in pre-order.
 abstract class RecursiveVisitor extends Visitor {
   const RecursiveVisitor();
 
   // Ensures that RecursiveVisitor contains overrides for all relevant nodes.
   // As a rule of thumb, nodes with structure to traverse should be overridden
   // with the appropriate visits in this class (for example, visitLetCont),
@@ skipping 246 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 231 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);
+  }
 }