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 154 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(FunctionElement element,
+                                          Selector selector,
+                                          InterfaceType type,
+                                          List<ir.Primitive> arguments) {
+    assert(isOpen);
+    // TODO(karlklose): resolve effective target and type here or inline later?

[asgerf, 2015/03/24 12:37:21]

I don't understand this TODO. Please clarify or resolve it.

[karlklose, 2015/03/26 09:50:07]

To implement redirecting factory constructors, we can either shortcut the call
here by computing effective target and type for the call, or we can compile the
redirecting factory and try to inline the call.

I removed the TODO here, since it is only valid for one of the alternatives.

+    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);
+      // TODO(karlklose): optimization: share the type expression for variables.

[asgerf, 2015/03/24 12:37:21]

Doesn't seem worthwhile, considering how rarely it happens, and when it does
happen, GVN will do it for us anyway.

[karlklose, 2015/03/26 09:50:07]

Done.

+      List<ir.Primitive> arguments = <ir.Primitive>[];
+      type.forEachTypeVariable((TypeVariableType variable) {
+        ir.Primitive value = buildTypeExpression(variable);

[asgerf, 2015/03/24 12:37:21]

It would be more clear to call buildTypeVariableAccess directly. Right now the
function looks recursive but actually isn't.

[karlklose, 2015/03/26 09:50:07]

Done.

+        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.';
+    }

[asgerf, 2015/03/24 12:37:21]

IMO a better alternative is to implement == and hashCode in
TypeInformationParameter and then use environment.lookup.

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