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

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 2017 matching lines @@
   @override
   ir.Primitive buildReifyTypeVariable(ir.Primitive target,
                                       TypeVariableType variable) {
     assert(target == irBuilder.state.enclosingMethodThisParameter);
     ir.Primitive prim = new ir.ReifyTypeVar(variable.element);
     irBuilder.add(new ir.LetPrim(prim));
     return prim;
   }
 }
 
+/// The [IrBuilder]s view on the information about the program that has been
+/// computed in resolution and and type interence.
+class GlobalProgramInformation {
+  final Compiler _compiler;
+  JavaScriptBackend get _backend => _compiler.backend;
+
+  GlobalProgramInformation(this._compiler);
+
+  /// Returns [true], if the analysis could not determine that the type
+  /// arguments for the class [cls] are never used in the program.
+  bool requiresRuntimeTypesFor(ClassElement cls) {
+    return cls.typeVariables.isNotEmpty && _backend.classNeedsRti(cls);
+  }
+}
+
 /// 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.
   /// It is computed by the [ClosureTranslator].
   ClosureClassMap closureMap;
@@ skipping 125 matching lines @@
   /// Such constants need to be compiled with a different [sourceFile] and
   /// [elements] mapping.
   ir.Primitive inlineConstant(AstElement context, ast.Expression exp) {
     JsIrBuilderVisitor visitor = new JsIrBuilderVisitor(
         context.resolvedAst.elements,
         compiler,
         sourceInformationBuilder.forContext(context));
     return visitor.withBuilder(irBuilder, () => visitor.translateConstant(exp));
   }
 
+  JsIrBuilder getBuilderFor(Element element) {
+    return new JsIrBuilder(
+        new GlobalProgramInformation(compiler),
+        compiler.backend.constantSystem,
+        element);
+  }
+
   /// Builds the IR for a given constructor.
   ///
   /// 1. Evaluates all own or inherited field initializers.
   /// 2. Creates the object and assigns its fields.
   /// 3. Calls constructor body and super constructor bodies.
   /// 4. Returns the created object.
   ir.FunctionDefinition buildConstructor(ConstructorElement constructor) {
     constructor = constructor.implementation;
     ClassElement classElement = constructor.enclosingClass.implementation;
 
-    JsIrBuilder builder =
-        new JsIrBuilder(compiler.backend.constantSystem, constructor);
+    JsIrBuilder builder = getBuilderFor(constructor);
+
+    final bool requiresTypeInformation =
+        builder.program.requiresRuntimeTypesFor(classElement);
 
     return withBuilder(builder, () {
       // Setup parameters and create a box if anything is captured.
-      List<ParameterElement> parameters = [];
-      constructor.functionSignature.orderedForEachParameter(parameters.add);
-      builder.buildFunctionHeader(parameters,
+      List<Local> parameters = <Local>[];
+      constructor.functionSignature.orderedForEachParameter(
+          (ParameterElement p) => parameters.add(p));
+
+      int firstTypeArgumentParameterIndex;
+
+      // If instances of the class may need runtime type information, we add a
+      // synthetic parameter for each type parameter.
+      if (requiresTypeInformation) {
+        firstTypeArgumentParameterIndex = parameters.length;
+        classElement.typeVariables.forEach((TypeVariableType variable) {
+          parameters.add(
+              new TypeInformationParameter(variable.element, constructor));
+        });
+      }
+
+      // Create IR parameters and setup the environment.
+      List<ir.Parameter> irParameters = builder.buildFunctionHeader(parameters,
           closureScope: getClosureScopeForFunction(constructor));
 
+      // Create a list of the values of all type argument parameters, if any.
+      List<ir.Primitive> typeInformation;
+      if (requiresTypeInformation) {
+        typeInformation = irParameters.sublist(firstTypeArgumentParameterIndex);
+      } else {
+        typeInformation = const <ir.Primitive>[];
+      }
+
       // -- Step 1: evaluate field initializers ---
       // Evaluate field initializers in constructor and super constructors.
+      irBuilder.enterInitializers();
       List<ConstructorElement> constructorList = <ConstructorElement>[];
       evaluateConstructorFieldInitializers(constructor, constructorList);
+      irBuilder.leaveInitializers();
 
       // All parameters in all constructors are now bound in the environment.
       // BoxLocals for captured parameters are also in the environment.
       // The initial value of all fields are now bound in [fieldValues].
 
       // --- Step 2: create the object ---
       // Get the initial field values in the canonical order.
       List<ir.Primitive> instanceArguments = <ir.Primitive>[];
       classElement.forEachInstanceField((ClassElement c, FieldElement field) {
         ir.Primitive value = fieldValues[field];
         if (value != null) {
           instanceArguments.add(fieldValues[field]);
         } else {
           assert(Elements.isNativeOrExtendsNative(c));
           // Native fields are initialized elsewhere.
         }
       }, includeSuperAndInjectedMembers: true);
-      ir.Primitive instance =
-          new ir.CreateInstance(classElement, instanceArguments);
+      ir.Primitive instance = new ir.CreateInstance(
+          classElement,
+          instanceArguments,
+          typeInformation);
       irBuilder.add(new ir.LetPrim(instance));
 
       // --- Step 3: call constructor bodies ---
       for (ConstructorElement target in constructorList) {
         ConstructorBodyElement bodyElement = getConstructorBody(target);
         if (bodyElement == null) continue; // Skip if constructor has no body.
         List<ir.Primitive> bodyArguments = <ir.Primitive>[];
         for (Local param in getConstructorBodyParameters(bodyElement)) {
           bodyArguments.add(irBuilder.environment.lookup(param));
         }
@@ skipping 213 matching lines @@
   /// This function is invoked from one or more "factory" constructors built by
   /// [buildConstructor].
   ir.FunctionDefinition buildConstructorBody(ConstructorBodyElement body) {
     ConstructorElement constructor = body.constructor;
     ast.FunctionExpression node = constructor.node;
     closureMap = compiler.closureToClassMapper.computeClosureToClassMapping(
         constructor,
         node,
         elements);
 
-    JsIrBuilder builder =
-        new JsIrBuilder(compiler.backend.constantSystem, body);
+    JsIrBuilder builder = getBuilderFor(body);
 
     return withBuilder(builder, () {
       irBuilder.buildConstructorBodyHeader(getConstructorBodyParameters(body),
                                            getClosureScopeForNode(node));
       visit(node.body);
       return irBuilder.makeFunctionDefinition([]);
     });
   }
 
   ir.FunctionDefinition buildFunction(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
     ast.FunctionExpression node = element.node;
 
     assert(!element.isSynthesized);
     assert(node != null);
     assert(elements[node] != null);
 
     closureMap = compiler.closureToClassMapper.computeClosureToClassMapping(
         element,
         node,
         elements);
-    IrBuilder builder =
-        new JsIrBuilder(compiler.backend.constantSystem, element);
+    IrBuilder builder = getBuilderFor(element);
     return withBuilder(builder, () => _makeFunctionBody(element, node));
   }
 
   /// Creates a primitive for the default value of [parameter].
   ir.Primitive translateDefaultValue(ParameterElement parameter) {
     if (parameter.initializer == null) {
       return irBuilder.buildNullLiteral();
     } else {
       return inlineConstant(parameter.executableContext, parameter.initializer);
     }
@@ skipping 61 matching lines @@
       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) {
-    ir.Primitive typeArgument = new ir.ReadTypeVariable(variable, target);
-    irBuilder.add(new ir.LetPrim(typeArgument));
+    ir.Primitive typeArgument =
+        irBuilder.buildTypeVariableAccess(target, variable);
+
     ir.Primitive type = new ir.ReifyRuntimeType(typeArgument);
     irBuilder.add(new ir.LetPrim(type));
     return type;
   }
 }
 
 /// Interface for generating [SourceInformation] for the CPS.
 class SourceInformationBuilder {
   const SourceInformationBuilder();
 
@@ skipping 26 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }