Remove use of JS templates in reified type information

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 3780 matching lines @@
   HInstruction invokeInterceptor(HInstruction receiver) {
     HInterceptor interceptor = new HInterceptor(receiver, backend.nonNullType);
     add(interceptor);
     return interceptor;
   }
 
   HLiteralList buildLiteralList(List<HInstruction> inputs) {
     return new HLiteralList(inputs, backend.extendableArrayType);
   }
 
-  // TODO(karlklose): change construction of the representations to be GVN'able
-  // (dartbug.com/7182).
   HInstruction buildTypeArgumentRepresentations(DartType type) {
+    assert(!type.isTypeVariable);
     // Compute the representation of the type arguments, including access
     // to the runtime type information for type variables as instructions.
-    if (type.isTypeVariable) {
-      return buildLiteralList(<HInstruction>[addTypeVariableReference(type)]);

[sra1, 2016/08/19 22:21:32]

This makes no sense and the path is infeasible. Dead code.

-    } else {
-      assert(type.element.isClass);
-      InterfaceType interface = type;
-      List<HInstruction> inputs = <HInstruction>[];
-      List<js.Expression> templates = <js.Expression>[];
-      for (DartType argument in interface.typeArguments) {
-        // As we construct the template in stages, we have to make sure that for
-        // each part the generated sub-template's holes match the index of the
-        // inputs that are later used to instantiate it. We do this by starting
-        // the indexing with the number of inputs from previous sub-templates.
-        templates.add(rtiEncoder.getTypeRepresentationWithPlaceholders(argument,
-            (variable) {
-          HInstruction runtimeType = addTypeVariableReference(variable);
-          inputs.add(runtimeType);
-        }, firstPlaceholderIndex: inputs.length));
-      }
-      // TODO(sra): This is a fresh template each time.  We can't let the
-      // template manager build them.
-      js.Template code =
-          new js.Template(null, new js.ArrayInitializer(templates));
-      HInstruction representation = new HForeignCode(
-          code, backend.readableArrayType, inputs,
-          nativeBehavior: native.NativeBehavior.PURE_ALLOCATION);
-      return representation;
+    assert(type.element.isClass);
+    InterfaceType interface = type;
+    List<HInstruction> inputs = <HInstruction>[];
+    for (DartType argument in interface.typeArguments) {
+      inputs.add(analyzeTypeArgument(argument));
     }
+    HInstruction representation = new HTypeInfoExpression(
+        TypeInfoExpressionKind.INSTANCE,
+        interface.element.thisType,
+        inputs,
+        backend.dynamicType);
+    return representation;
   }
 
   @override
   void visitAs(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     if (type.isMalformed) {
       String message;
       if (type is MalformedType) {
         ErroneousElement element = type.element;
         message = element.message;
@@ skipping 4812 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }