cps-ir: Set runtime type information for new objects that require it.

pkg/compiler/lib/src/js_backend/codegen/codegen.dart

Index: pkg/compiler/lib/src/js_backend/codegen/codegen.dart
diff --git a/pkg/compiler/lib/src/js_backend/codegen/codegen.dart b/pkg/compiler/lib/src/js_backend/codegen/codegen.dart
index f6c7e21608b46c268c89575c9d7531f6141c63e8..e0a220d327725d828cf69d886538ce029072e05e 100644
--- a/pkg/compiler/lib/src/js_backend/codegen/codegen.dart
+++ b/pkg/compiler/lib/src/js_backend/codegen/codegen.dart
@@ -206,13 +206,24 @@ class CodeGenerator extends tree_ir.Visitor<dynamic, js.Expression> {
   @override
   js.Expression visitInvokeConstructor(tree_ir.InvokeConstructor node) {
     checkStaticTargetIsValid(node, node.target);
-
+    assert(node.type == null);
     if (node.constant != null) return giveup(node);
-    registry.registerInstantiatedClass(node.target.enclosingClass);
+
+    ClassElement instantiatedClass = node.target.enclosingClass;
+    registry.registerInstantiatedClass(instantiatedClass);
     Selector selector = node.selector;
     FunctionElement target = node.target;
     List<js.Expression> arguments = visitArguments(node.arguments);
-    return buildStaticInvoke(selector, target, arguments);
+    js.Expression object = buildStaticInvoke(selector, target, arguments);

[asgerf, 2015/03/18 10:18:07]

It seems we are using InvokeConstuctor to call the constructor factory, 
CreateInstance to invoke the JS constructor, and InvokeMethodDirectly to invoke
constructor bodies.

Type arguments should be set immediately after the JS constructor returns, but
here they are set after the factory returns (i.e. where the constructor is
completely done).

This will not work, because the object will not have type information while the
constructor bodies are running.

For example:

class Foo<T> {
    var field;
    Foo() {
        m();
    }
    m() { field = T; }
}

In the above case, the call to m() does not see the right value of T.

The type arguments should be passed as arguments to the constructor factory,
which should then use them in the CreateInstance instruction where the actual JS
constructor is invoked.

The code here for handling type arguments should then be in visitCreateInstance.

I think InvokeConstructor should be made Dart-specific to avoid this kind of
confusion in the future (it's not clear what kind of constructor is being
invoked). We can invoke constructor factories using InvokeStatic, passing type
arguments as ordinary arguments.

This requires updates to JsIrBuilderVisitor.buildConstructor in order to handle
the extra parameters.

+    if (!node.typeArguments.isEmpty) {
+      FunctionElement helper = glue.getAddRuntimeTypeInformation();
+      List<js.Expression> typeArguments = visitArguments(node.typeArguments);
+      js.Expression typeInformation = new js.ArrayInitializer(typeArguments);
+      return buildStaticHelperInvocation(helper,
+          <js.Expression>[object, typeInformation]);
+    } else {
+      return object;
+    }
   }
 
   void registerMethodInvoke(tree_ir.InvokeMethod node) {
@@ -555,6 +566,12 @@ class CodeGenerator extends tree_ir.Visitor<dynamic, js.Expression> {
     }
   }
 
+  @override
+  js.Expression visitTypeExpression(tree_ir.TypeExpression node) {
+    List<js.Expression> arguments =
+        node.arguments.map(visitExpression).toList(growable: false);
+    return glue.generateTypeRepresentation(node.dartType, arguments);
+  }
 
   // Dart-specific IR nodes