Implement type argument access and reification of runtime types.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.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.
 
 part of dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
@@ skipping 839 matching lines @@
     assert(irBuilder.isOpen);
     // If the user is trying to invoke the type literal or variable,
     // it must be treated as a function call.
     if (node.argumentsNode != null) {
       // TODO(sigurdm): Handle this to match proposed semantics of issue #19725.
       return giveup(node, 'Type literal invoked as function');
     }
 
     DartType type = elements.getTypeLiteralType(node);
     if (type is TypeVariableType) {
-      ir.Primitive prim = new ir.ReifyTypeVar(type.element);
-      irBuilder.add(new ir.LetPrim(prim));
-      return prim;
+      return buildReifyTypeVariable(irBuilder.buildThis(), type);
     } else {
       return translateConstant(node);
     }
   }
 
+  ir.Primitive buildReifyTypeVariable(ir.Primitive target,
+                                      TypeVariableType variable);
+
   ir.Primitive visitSendSet(ast.SendSet node) {
     assert(irBuilder.isOpen);
     Element element = elements[node];
     ast.Operator op = node.assignmentOperator;
     // For complex operators, this is the result of getting (before assigning)
     ir.Primitive originalValue;
     // For []+= style operators, this saves the index.
     ir.Primitive index;
     ir.Primitive receiver;
     // This is what gets assigned.
@@ skipping 393 matching lines @@
       FunctionElement target,
       List<ir.Primitive> arguments) {
     return arguments;
   }
 
   List<ir.Primitive> normalizeDynamicArguments(
       Selector selector,
       List<ir.Primitive> arguments) {
     return arguments;
   }
+
+  @override
+  ir.Primitive buildReifyTypeVariable(ir.Primitive target,
+                                      TypeVariableType variable) {
+    assert(target is ir.This);
+    ir.Primitive prim = new ir.ReifyTypeVar(variable.element);
+    irBuilder.add(new ir.LetPrim(prim));
+    return prim;
+  }
 }
 
 /// IR builder specific to the JavaScript backend, coupled to the [JsIrBuilder].
 class JsIrBuilderVisitor extends IrBuilderVisitor {
   /// Promote the type of [irBuilder] to [JsIrBuilder].
   JsIrBuilder get irBuilder => super.irBuilder;
 
   /// Result of closure conversion for the current body of code.
   ///
   /// Will be initialized upon entering the body of a function.
@@ skipping 505 matching lines @@
     for (int i=0; i < selector.positionalArgumentCount; i++) {
       result.add(arguments[i]);
     }
     for (String argName in selector.getOrderedNamedArguments()) {
       int nameIndex = selector.namedArguments.indexOf(argName);
       int translatedIndex = selector.positionalArgumentCount + nameIndex;
       result.add(arguments[translatedIndex]);
     }
     return result;
   }
+
+  @override
+  ir.Primitive buildReifyTypeVariable(ir.Primitive target,
+                                      TypeVariableType variable) {
+    ir.Primitive typeArgument = new ir.ReadTypeVariable(variable, target);
+    irBuilder.add(new ir.LetPrim(typeArgument));
+    ir.Primitive type = new ir.ReifyRuntimeType(typeArgument);
+    irBuilder.add(new ir.LetPrim(type));
+    return type;
+  }
 }
 
 /// Interface for generating [SourceInformation] for the CPS.
 class SourceInformationBuilder {
   const SourceInformationBuilder();
 
   /// Create a [SourceInformationBuilder] for [element].
   SourceInformationBuilder forContext(AstElement element) => this;
 
   /// Generate [SourceInformation] for the read access in [node].
@@ skipping 22 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }