typeInformation in CreateInstance is a kind of TypeExpression

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 closure;
 import '../common.dart';
 import '../common/names.dart' show
     Names,
@@ skipping 364 matching lines @@
   /// 5. Returns the created object.
   ir.FunctionDefinition buildConstructor(ConstructorElement constructor) {
     // TODO(asgerf): Optimization: If constructor is redirecting, then just
     //               evaluate arguments and call the target constructor.
     constructor = constructor.implementation;
     ClassElement classElement = constructor.enclosingClass.implementation;
 
     IrBuilder builder = getBuilderFor(constructor);
 
     final bool requiresTypeInformation =
-    builder.program.requiresRuntimeTypesFor(classElement);
+        builder.program.requiresRuntimeTypesFor(classElement);
 
     return withBuilder(builder, () {
       // Setup parameters and create a box if anything is captured.
       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 closure.TypeVariableLocal(variable, constructor));
         });
       } else {
         classElement.typeVariables.forEach((TypeVariableType variable) {
           irBuilder.declareTypeVariable(variable, const DynamicType());
         });
       }
 
       // 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;
+      ir.Primitive typeInformation;
       if (requiresTypeInformation) {
-        typeInformation = irParameters.sublist(firstTypeArgumentParameterIndex);
+        typeInformation = new ir.TypeExpression(
+            ir.TypeExpressionKind.INSTANCE,
+            classElement.thisType,
+            irParameters.sublist(firstTypeArgumentParameterIndex));
+        irBuilder.add(new ir.LetPrim(typeInformation));
       } else {
-        typeInformation = const <ir.Primitive>[];
+        typeInformation = null;
       }
 
       // -- Load values for type variables declared on super classes --
       // Field initializers for super classes can reference these, so they
       // must be available before evaluating field initializers.
       // This could be interleaved with field initialization, but we choose do
       // get it out of the way here to avoid complications with mixins.
       loadTypeVariablesForSuperClasses(classElement);
 
       /// Maps each field from this class or a superclass to its initial value.
@@ skipping 3395 matching lines @@
   }
 
   Element get closureConverter {
     return _backend.helpers.closureConverter;
   }
 
   void addNativeMethod(FunctionElement function) {
     _backend.emitter.nativeEmitter.nativeMethods.add(function);
   }
 }