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 938 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(new ir.This(), type);

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

Use irBuilder.buildThis(), otherwise 'this' inside a nested function will be
translated to a JS 'this' instead of the captured receiver.

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

Done.

     } 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);

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

FYI I believe this assertion is still valid with the above change.

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

Acknowledged.

+    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 506 matching lines @@
       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) {
+    ClassElement context = variable.element.enclosingClass;
+    irBuilder.add(new ir.LetPrim(target));
+    ir.Primitive typeArgument =
+        new ir.ReadTypeVariable(variable, context, target);

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

This seems wrong. We are always passing variable.element.enclosingClass as the
context. Why do we have two fields when one can be derived from the other? (Also
see long comment in the ir_nodes file).

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

I removed the context. We do not need it until we inline or specialize and we
should introduce it, when we need it for these features.

+    irBuilder.add(new ir.LetPrim(typeArgument));
+    var type = new ir.ReifyRuntimeType(typeArgument);
+    irBuilder.add(new ir.LetPrim(type));
+    return type;
+  }
 }