dart2js: Construct the entire output as a single AST before printing.

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.
 
 part of ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 3538 matching lines @@
   HInstruction buildTypeArgumentRepresentations(DartType type) {
     // 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)]);
     } else {
       assert(type.element.isClass);
       InterfaceType interface = type;
       List<HInstruction> inputs = <HInstruction>[];
       bool first = true;
-      List<String> templates = <String>[];
+      List<js.Expression> templates = <js.Expression>[];
       for (DartType argument in interface.typeArguments) {
         templates.add(rti.getTypeRepresentationWithHashes(argument, (variable) {
           HInstruction runtimeType = addTypeVariableReference(variable);
           inputs.add(runtimeType);
         }));
       }
-      String template = '[${templates.join(', ')}]';
       // TODO(sra): This is a fresh template each time.  We can't let the
       // template manager build them.
-      js.Template code = js.js.uncachedExpressionTemplate(template);
+      js.Template code = new js.Template.withExpressionResult(
+          new js.ArrayInitializer(templates), hasPlaceholders : true);
       HInstruction representation =
           new HForeignCode(code, backend.readableArrayType, inputs,
               nativeBehavior: native.NativeBehavior.PURE_ALLOCATION);
       return representation;
     }
   }
 
   @override
   void visitAs(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
@@ skipping 1036 matching lines @@
       // Represent [dynamic] as [null].
       return graph.addConstantNull(compiler);
     }
 
     if (argument.isTypeVariable) {
       return addTypeVariableReference(argument);
     }
 
     List<HInstruction> inputs = <HInstruction>[];
 
-    String template = rti.getTypeRepresentationWithHashes(argument, (variable) {
-      inputs.add(addTypeVariableReference(variable));
-    });
+    js.Expression template =
+        rti.getTypeRepresentationWithHashes(argument,

[floitsch, 2015/05/19 13:43:35]

looks like it fits on one line.

[herhut, 2015/05/19 14:08:09]

Done.

+                                            (variable) {
+            inputs.add(addTypeVariableReference(variable));
+        });
 
-    js.Template code = js.js.uncachedExpressionTemplate(template);
+    js.Template code =
+        new js.Template.withExpressionResult(template, hasPlaceholders : true);
     HInstruction result = new HForeignCode(code, backend.stringType, inputs,
         nativeBehavior: native.NativeBehavior.PURE);
     add(result);
     return result;
   }
 
   HInstruction handleListConstructor(InterfaceType type,
                                      ast.Node currentNode,
                                      HInstruction newObject) {
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
@@ skipping 3027 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }