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

pkg/compiler/lib/src/cps_ir/cps_ir_builder.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.
 
 library dart2js.ir_builder;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../tree/tree.dart' as ast;
 import '../closure.dart' hide ClosureScope;
 import 'cps_ir_nodes.dart' as ir;
-import 'cps_ir_builder_task.dart' show DartCapturedVariables;
+import 'cps_ir_builder_task.dart' show DartCapturedVariables,
+    GlobalProgramInformation;
 
 /// A mapping from variable elements to their compile-time values.
 ///
 /// Map elements denoted by parameters and local variables to the
 /// [ir.Primitive] that is their value.  Parameters and locals are
 /// assigned indexes which can be used to refer to them.
 class Environment {
   /// A map from locals to their environment index.
   final Map<Local, int> variable2index;
 
@@ skipping 274 matching lines @@
   /// Called before building the body of a for-loop.
   void _enterForLoopBody(ClosureScope scope,
                          List<LocalElement> loopVariables);
 
   /// Called before building the update of a for-loop.
   void _enterForLoopUpdate(ClosureScope scope,
                            List<LocalElement> loopVariables);
 
   /// Add the given function parameter to the IR, and bind it in the environment
   /// or put it in its box, if necessary.
-  void _createFunctionParameter(ParameterElement parameterElement);
+  void _createFunctionParameter(Local parameterElement);
   void _createThisParameter();
 
   /// Creates an access to the receiver from the current (or enclosing) method.
   ///
   /// If inside a closure class, [buildThis] will redirect access through
   /// closure fields in order to access the receiver from the enclosing method.
   ir.Primitive buildThis();
 
   // TODO(johnniwinther): Make these field final and remove the default values
   // when [IrBuilder] is a property of [IrBuilderVisitor] instead of a mixin.
@@ skipping 87 matching lines @@
         ..environment = new Environment.empty();
   }
 
   bool get isOpen => _root == null || _current != null;
 
 
   void buildFieldInitializerHeader({ClosureScope closureScope}) {
     _enterScope(closureScope);
   }
 
-  List<ir.Primitive> buildFunctionHeader(Iterable<ParameterElement> parameters,
+  List<ir.Primitive> buildFunctionHeader(Iterable<Local> parameters,
                                         {ClosureScope closureScope,
                                          ClosureEnvironment env}) {
     _createThisParameter();
     _enterClosureEnvironment(env);
     _enterScope(closureScope);
     parameters.forEach(_createFunctionParameter);
     return _parameters;
   }
 
   /// Creates a parameter for [local] and adds it to the current environment.
@@ skipping 391 matching lines @@
     _buildInvokeStatic(
         element, selector, <ir.Primitive>[value], sourceInformation);
     return value;
   }
 
   /// Create a constructor invocation of [element] on [type] where the
   /// constructor name and argument structure are defined by [selector] and the
   /// argument values are defined by [arguments].
   ir.Primitive buildConstructorInvocation(FunctionElement element,
                                           Selector selector,
-                                          DartType type,
-                                          List<ir.Primitive> arguments) {
-    assert(isOpen);
-    return _continueWithExpression(
-        (k) => new ir.InvokeConstructor(type, element, selector, k, arguments));
-  }
+                                          InterfaceType type,
+                                          List<ir.Primitive> arguments);
 
   /// Create a string concatenation of the [arguments].
   ir.Primitive buildStringConcatenation(List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.ConcatenateStrings(k, arguments));
   }
 
   /// Create an invocation of the `call` method of [functionExpression], where
   /// the named arguments are given by [selector].
@@ skipping 1216 matching lines @@
       if (isInMutableVariable(loopVariable)) {
         ir.MutableVariable mutableVariable = getMutableVariable(loopVariable);
         ir.Primitive value =
             addPrimitive(new ir.GetMutableVariable(mutableVariable));
         environment.update(loopVariable, value);
         dartState.registerizedMutableVariables.add(loopVariable);
       }
     }
   }
 
-  void _createFunctionParameter(ParameterElement parameterElement) {
+  void _createFunctionParameter(Local parameterElement) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
     if (isInMutableVariable(parameterElement)) {
       state.functionParameters.add(getMutableVariable(parameterElement));
     } else {
       state.functionParameters.add(parameter);
       environment.extend(parameterElement, parameter);
     }
   }
 
@@ skipping 78 matching lines @@
   ir.Primitive buildThis() {
     return state.enclosingMethodThisParameter;
   }
 
   ir.Primitive buildSuperInvocation(Element target,
                                     Selector selector,
                                     List<ir.Primitive> arguments) {
     return _buildInvokeSuper(target, selector, arguments);
   }
 
+  @override
+  ir.Primitive buildConstructorInvocation(FunctionElement element,
+                                          Selector selector,
+                                          InterfaceType type,
+                                          List<ir.Primitive> arguments) {
+    assert(isOpen);
+    return _continueWithExpression(
+        (k) => new ir.InvokeConstructor(type, element, selector, k,
+            arguments));
+  }
 }
 
 /// State shared between JsIrBuilders within the same function.
 ///
 /// Note that this is not shared between builders of nested functions.
 class JsIrBuilderSharedState {
   /// Maps boxed locals to their location. These locals are not part of
   /// the environment.
   final Map<Local, ClosureLocation> boxedVariables = {};
 
   /// If non-null, this refers to the receiver (`this`) in the enclosing method.
   ir.Primitive receiver;
+
+  /// `true` when we are currently building expressions inside the initializer
+  /// list of a constructor.
+  bool inInitializers = false;
 }
 
 /// JS-specific subclass of [IrBuilder].
 ///
 /// Inner functions are represented by a [ClosureClassElement], and captured
 /// variables are boxed as necessary using [CreateBox], [GetField], [SetField].
 class JsIrBuilder extends IrBuilder {
   final JsIrBuilderSharedState jsState;
+  final GlobalProgramInformation program;
 
-  IrBuilder _makeInstance() => new JsIrBuilder._blank(jsState);
-  JsIrBuilder._blank(this.jsState);
+  IrBuilder _makeInstance() => new JsIrBuilder._blank(program, jsState);
+  JsIrBuilder._blank(this.program, this.jsState);
 
-  JsIrBuilder(ConstantSystem constantSystem, ExecutableElement currentElement)
+  JsIrBuilder(this.program, ConstantSystem constantSystem,
+      ExecutableElement currentElement)
       : jsState = new JsIrBuilderSharedState() {
     _init(constantSystem, currentElement);
   }
 
   Map<ast.TryStatement, TryStatementInfo> get tryStatements => null;
   Set<Local> get mutableCapturedVariables => null;
   bool isInMutableVariable(Local local) => false;
   void makeMutableVariable(Local local) {}
   void removeMutableVariable(Local local) {}
 
+  void enterInitializers() {
+    assert(jsState.inInitializers == false);
+    jsState.inInitializers = true;
+  }
+
+  void leaveInitializers() {
+    assert(jsState.inInitializers == true);
+    jsState.inInitializers = false;
+  }
+
   void _enterClosureEnvironment(ClosureEnvironment env) {
     if (env == null) return;
 
     // Obtain a reference to the function object (this).
     ir.Parameter thisPrim = state.thisParameter;
 
     // Obtain access to the free variables.
     env.freeVariables.forEach((Local local, ClosureLocation location) {
       if (location.isBox) {
         // Boxed variables are loaded from their box on-demand.
@@ skipping 31 matching lines @@
     environment.extend(scope.box, boxPrim);
     boxPrim.useElementAsHint(scope.box);
     scope.capturedVariables.forEach((Local local, ClosureLocation location) {
       assert(!jsState.boxedVariables.containsKey(local));
       if (location.isBox) {
         jsState.boxedVariables[local] = location;
       }
     });
   }
 
-  void _createFunctionParameter(ParameterElement parameterElement) {
+  void _createFunctionParameter(Local parameterElement) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
     state.functionParameters.add(parameter);
     ClosureLocation location = jsState.boxedVariables[parameterElement];
     if (location != null) {
       add(new ir.SetField(environment.lookup(location.box),
                           location.field,
                           parameter));
     } else {
       environment.extend(parameterElement, parameter);
@@ skipping 34 matching lines @@
   ir.Primitive buildFunctionExpression(ClosureClassElement classElement) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     for (ClosureFieldElement field in classElement.closureFields) {
       // Captured 'this' is not available as a local in the current environment,
       // so treat that specially.
       ir.Primitive value = field.local is ThisLocal
           ? buildThis()
           : environment.lookup(field.local);
       arguments.add(value);
     }
-    return addPrimitive(new ir.CreateInstance(classElement, arguments));
+    return addPrimitive(
+        new ir.CreateInstance(classElement, arguments, const <ir.Primitive>[]));
   }
 
   /// Create a read access of [local].
   ir.Primitive buildLocalGet(LocalElement local) {
     assert(isOpen);
     ClosureLocation location = jsState.boxedVariables[local];
     if (location != null) {
       ir.Primitive result = new ir.GetField(environment.lookup(location.box),
                                             location.field);
       result.useElementAsHint(local);
@@ skipping 99 matching lines @@
                                   ClosureScope closureScope) {
     _createThisParameter();
     for (Local param in parameters) {
       ir.Parameter parameter = createLocalParameter(param);
       state.functionParameters.add(parameter);
     }
     if (closureScope != null) {
       jsState.boxedVariables.addAll(closureScope.capturedVariables);
     }
   }
+
+  @override
+  ir.Primitive buildConstructorInvocation(ConstructorElement element,
+                                          Selector selector,
+                                          InterfaceType type,
+                                          List<ir.Primitive> arguments) {
+    assert(isOpen);
+
+    ClassElement cls = element.enclosingClass;
+    if (program.requiresRuntimeTypesFor(cls)) {
+      Iterable<ir.Primitive> typeArguments =
+          type.typeArguments.map((DartType argument) {
+        return type.treatAsRaw
+            ? buildNullLiteral()
+            : buildTypeExpression(argument);
+      });
+      arguments = new List<ir.Primitive>.from(arguments)
+          ..addAll(typeArguments);
+    }
+    return _continueWithExpression(
+        (k) => new ir.InvokeConstructor(type, element, selector, k,
+            arguments));
+  }
+
+  ir.Primitive buildTypeExpression(DartType type) {
+    if (type is TypeVariableType) {
+      return buildTypeVariableAccess(buildThis(), type);
+    } else {
+      assert(type is InterfaceType);
+      List<ir.Primitive> arguments = <ir.Primitive>[];
+      type.forEachTypeVariable((TypeVariableType variable) {
+        ir.Primitive value = buildTypeVariableAccess(buildThis(), variable);
+        arguments.add(value);
+      });
+      return addPrimitive(new ir.TypeExpression(type, arguments));
+    }
+  }
+
+  ir.Primitive buildTypeVariableAccess(ir.Primitive target,
+                                       TypeVariableType variable) {
+    ir.Parameter accessTypeArgumentParameter() {
+      for (int i = 0; i < environment.length; i++) {
+        Local local = environment.index2variable[i];
+        if (local is TypeInformationParameter &&
+            local.variable == variable.element) {
+          return environment.index2value[i];
+        }
+      }
+      throw 'unable to find constructor parameter for type variable $variable.';
+    }
+
+    if (jsState.inInitializers) {
+      return accessTypeArgumentParameter();
+    } else {
+      return addPrimitive(new ir.ReadTypeVariable(variable, target));
+    }
+  }
 }
 
 
 /// Location of a variable relative to a given closure.
 class ClosureLocation {
   /// If not `null`, this location is [box].[field].
   /// The location of [box] can be obtained separately from an
   /// enclosing [ClosureEnvironment] or [ClosureScope].
   /// If `null`, then the location is [field] on the enclosing function object.
   final BoxLocal box;
@@ skipping 51 matching lines @@
 // TODO(johnniwinther): Support passing of [DartType] for the exception.
 class CatchClauseInfo {
   final LocalVariableElement exceptionVariable;
   final LocalVariableElement stackTraceVariable;
   final SubbuildFunction buildCatchBlock;
 
   CatchClauseInfo({this.exceptionVariable,
                    this.stackTraceVariable,
                    this.buildCatchBlock});
 }
+
+/// Synthetic parameter to a JavaScript factory method that takes the type
+/// argument given for the type variable [variable].
+class TypeInformationParameter implements Local {
+  final TypeVariableElement variable;
+  final ExecutableElement executableContext;
+  TypeInformationParameter(this.variable, this.executableContext);
+  String get name => variable.name;
+}