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

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

 // Copyright (c) 2014, 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.
 
 library code_generator;
 
 import 'glue.dart';
 
 import '../../tree_ir/tree_ir_nodes.dart' as tree_ir;
 import '../../js/js.dart' as js;
@@ skipping 188 matching lines @@
     } else {
       js.Expression elementAccess = glue.staticFunctionAccess(target);
       return new js.Call(elementAccess, arguments,
           sourceInformation: sourceInformation);
     }
   }
 
   @override
   js.Expression visitInvokeConstructor(tree_ir.InvokeConstructor node) {
     checkStaticTargetIsValid(node, node.target);
+    assert(node.type == null);
+    if (node.constant != null) return giveup(node);
 
-    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) {
     Selector selector = node.selector;
     if (selector.isGetter) {
       registry.registerDynamicGetter(selector);
     } else if (selector.isSetter) {
       registry.registerDynamicSetter(selector);
     } else {
       assert(invariant(CURRENT_ELEMENT_SPANNABLE,
@@ skipping 322 matching lines @@
       return buildStaticHelperInvocation(
           glue.getTypeArgumentWithSubstitution(),
           [visitExpression(node.target), substitution, index]);
     } else {
       return buildStaticHelperInvocation(
           glue.getTypeArgumentByIndex(),
           [visitExpression(node.target), index]);
     }
   }
 
+  @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
 
   @override
   visitReifyTypeVar(tree_ir.ReifyTypeVar node) {
     return errorUnsupportedNode(node);
   }
 
   @override
   visitFunctionExpression(tree_ir.FunctionExpression node) {
@@ skipping 12 matching lines @@
 
   @override
   visitSuperInitializer(tree_ir.SuperInitializer node) {
     return errorUnsupportedNode(node);
   }
 
   errorUnsupportedNode(tree_ir.DartSpecificNode node) {
     throw "Unsupported node in JS backend: $node";
   }
 }