Add type arguments to lists in the code generator and make them fixed length.

pkg/compiler/lib/src/js_backend/codegen/codegen.dart

 // Copyright (c) 2014, 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 code_generator;
 
 import 'glue.dart';
 
 import '../../tree_ir/tree_ir_nodes.dart' as tree_ir;
 import '../../js/js.dart' as js;
@@ skipping 138 matching lines @@
         : variable.element.name);
     while (!usedVariableNames.add(name)) {
       ++counter;
       name = '$prefix$counter';
     }
     variableNames[variable] = name;
 
     return name;
   }
 
-  List<js.Expression> visitArguments(List<tree_ir.Expression> arguments) {
-    return arguments.map(visitExpression).toList();
+  List<js.Expression> visitExpressionList(List<tree_ir.Expression> expressions) {

[Johnni Winther, 2015/06/03 09:45:39]

Long line.

+    return new List<js.Expression>.generate(expressions.length,
+        (int index) => visitExpression(expressions[index]),
+        growable: false);
   }
 
   giveup(tree_ir.Node node,
          [String reason = 'unimplemented in CodeGenerator']) {
     throw new CodegenBailout(node, reason);
   }
 
   @override
   js.Expression visitConcatenateStrings(tree_ir.ConcatenateStrings node) {
     js.Expression addStrings(js.Expression left, js.Expression right) {
@@ skipping 64 matching lines @@
     }
   }
 
   @override
   js.Expression visitInvokeConstructor(tree_ir.InvokeConstructor node) {
     if (node.constant != null) return giveup(node);
 
     registry.registerInstantiatedType(node.type);
     Selector selector = node.selector;
     FunctionElement target = node.target;
-    List<js.Expression> arguments = visitArguments(node.arguments);
+    List<js.Expression> arguments = visitExpressionList(node.arguments);
     return buildStaticInvoke(selector, target, arguments);
   }
 
   void registerMethodInvoke(tree_ir.InvokeMethod node) {
     Selector selector = node.selector;
     if (selector.isGetter) {
       registry.registerDynamicGetter(selector);
     } else if (selector.isSetter) {
       registry.registerDynamicSetter(selector);
     } else {
       assert(invariant(CURRENT_ELEMENT_SPANNABLE,
           selector.isCall || selector.isOperator ||
           selector.isIndex || selector.isIndexSet,
           message: 'unexpected kind ${selector.kind}'));
       // TODO(sigurdm): We should find a better place to register the call.
       Selector call = new Selector.callClosureFrom(selector);
       registry.registerDynamicInvocation(call);
       registry.registerDynamicInvocation(selector);
     }
   }
 
   @override
   js.Expression visitInvokeMethod(tree_ir.InvokeMethod node) {
     registerMethodInvoke(node);
     return js.propertyCall(visitExpression(node.receiver),
                            glue.invocationName(node.selector),
-                           visitArguments(node.arguments));
+                           visitExpressionList(node.arguments));
   }
 
   @override
   js.Expression visitInvokeStatic(tree_ir.InvokeStatic node) {
     Selector selector = node.selector;
     assert(selector.isGetter || selector.isSetter || selector.isCall);
     FunctionElement target = node.target;
-    List<js.Expression> arguments = visitArguments(node.arguments);
+    List<js.Expression> arguments = visitExpressionList(node.arguments);
     return buildStaticInvoke(selector, target, arguments,
         sourceInformation: node.sourceInformation);
   }
 
   @override
   js.Expression visitInvokeMethodDirectly(tree_ir.InvokeMethodDirectly node) {
     registry.registerDirectInvocation(node.target.declaration);
     if (node.target is ConstructorBodyElement) {
       // A constructor body cannot be overriden or intercepted, so we can
       // use the short form for this invocation.
       return js.js('#.#(#)',
           [visitExpression(node.receiver),
            glue.instanceMethodName(node.target),
-           visitArguments(node.arguments)]);
+           visitExpressionList(node.arguments)]);
     }
     return js.js('#.#.call(#, #)',
         [glue.prototypeAccess(node.target.enclosingClass),
          glue.invocationName(node.selector),
          visitExpression(node.receiver),
-         visitArguments(node.arguments)]);
+         visitExpressionList(node.arguments)]);
   }
 
   @override
   js.Expression visitLiteralList(tree_ir.LiteralList node) {
     registry.registerInstantiatedClass(glue.listClass);
-    List<js.Expression> entries = node.values.map(visitExpression).toList();
+    List<js.Expression> entries = visitExpressionList(node.values);
     return new js.ArrayInitializer(entries);
   }
 
   @override
   js.Expression visitLiteralMap(tree_ir.LiteralMap node) {
     ConstructorElement constructor;
     if (node.entries.isEmpty) {
       constructor = glue.mapLiteralConstructorEmpty;
     } else {
       constructor = glue.mapLiteralConstructor;
@@ skipping 27 matching lines @@
   }
 
   @override
   js.Expression visitThis(tree_ir.This node) {
     return new js.This();
   }
 
   @override
   js.Expression visitTypeOperator(tree_ir.TypeOperator node) {
     js.Expression value = visitExpression(node.value);
-    List<js.Expression> typeArguments =
-        node.typeArguments.map(visitExpression).toList();
+    List<js.Expression> typeArguments = visitExpressionList(node.typeArguments);
     if (!node.isTypeTest) {
       giveup(node, 'type casts not implemented.');
     }
     DartType type = node.type;
     // Note that the trivial (but special) cases of Object, dynamic, and Null
     // are handled at build-time and must not occur in a TypeOperator.
     assert(!type.isObject && !type.isDynamic);
     if (type is InterfaceType) {
       glue.registerIsCheck(type, registry);
       ClassElement clazz = type.element;
@@ skipping 184 matching lines @@
     tree_ir.Variable exceptionVariable = node.catchParameters.first;
     js.VariableDeclaration exceptionParameter =
         new js.VariableDeclaration(getVariableName(exceptionVariable));
     js.Block catchBlock = buildBodyBlock(node.catchBody);
     js.Catch catchPart = new js.Catch(exceptionParameter, catchBlock);
     accumulator.add(new js.Try(tryBlock, catchPart, null));
   }
 
   @override
   js.Expression visitCreateBox(tree_ir.CreateBox node) {
-    return new js.ObjectInitializer([]);
+    return new js.ObjectInitializer(const <js.Property>[]);
   }
 
   @override
   js.Expression visitCreateInstance(tree_ir.CreateInstance node) {
     ClassElement cls = node.classElement;
     // TODO(asgerf): To allow inlining of InvokeConstructor, CreateInstance must
     //               carry a DartType so we can register the instantiated type
     //               with its type arguments. Otherwise dataflow analysis is
     //               needed to reconstruct the instantiated type.
     registry.registerInstantiatedClass(cls);
     js.Expression instance = new js.New(
         glue.constructorAccess(cls),
-        node.arguments.map(visitExpression).toList());
+        visitExpressionList(node.arguments));
 
     List<tree_ir.Expression> typeInformation = node.typeInformation;
     assert(typeInformation.isEmpty ||
         typeInformation.length == cls.typeVariables.length);
     if (typeInformation.isNotEmpty) {
       FunctionElement helper = glue.getAddRuntimeTypeInformation();
       js.Expression typeArguments = new js.ArrayInitializer(
-          typeInformation.map(visitExpression).toList());
+          visitExpressionList(typeInformation));
       return buildStaticHelperInvocation(helper,
           <js.Expression>[instance, typeArguments]);
     } else {
       return instance;
     }
   }
 
   @override
   js.Expression visitCreateInvocationMirror(
       tree_ir.CreateInvocationMirror node) {
     js.Expression name = js.string(node.selector.name);
     js.Expression internalName = js.string(glue.invocationName(node.selector));
     js.Expression kind = js.number(node.selector.invocationMirrorKind);
     js.Expression arguments = new js.ArrayInitializer(
-        node.arguments.map(visitExpression).toList());
+        visitExpressionList(node.arguments));
     js.Expression argumentNames = new js.ArrayInitializer(
-        node.selector.namedArguments.map(js.string).toList());
+        node.selector.namedArguments.map(js.string).toList(growable: false));
     return buildStaticHelperInvocation(glue.createInvocationMirrorMethod,
         [name, internalName, kind, arguments, argumentNames]);
   }
 
   @override
   js.Expression visitGetField(tree_ir.GetField node) {
     return new js.PropertyAccess.field(
         visitExpression(node.object),
         glue.instanceFieldPropertyName(node.field));
   }
@@ skipping 12 matching lines @@
     assert(node.element is FieldElement || node.element is FunctionElement);
     if (node.element is FunctionElement) {
       // Tear off a method.
       registry.registerGetOfStaticFunction(node.element.declaration);
       return glue.isolateStaticClosureAccess(node.element);
     }
     if (glue.isLazilyInitialized(node.element)) {
       // Read a lazily initialized field.
       registry.registerStaticUse(node.element.declaration);
       js.Expression getter = glue.isolateLazyInitializerAccess(node.element);
-      return new js.Call(getter, [], sourceInformation: node.sourceInformation);
+      return new js.Call(getter, <js.Expression>[],
+          sourceInformation: node.sourceInformation);
     }
     // Read an eagerly initialized field.
     registry.registerStaticUse(node.element.declaration);
     return glue.staticFieldAccess(node.element);
   }
 
   @override
   js.Expression visitSetStatic(tree_ir.SetStatic node) {
     assert(node.element is FieldElement);
     registry.registerStaticUse(node.element.declaration);
@@ skipping 29 matching lines @@
           [visitExpression(node.target), typeName, index]);
     } else {
       return buildStaticHelperInvocation(
           glue.getTypeArgumentByIndex(),
           [visitExpression(node.target), index]);
     }
   }
 
   @override
   js.Expression visitTypeExpression(tree_ir.TypeExpression node) {
-    List<js.Expression> arguments =
-        node.arguments.map(visitExpression).toList(growable: false);
+    List<js.Expression> arguments = visitExpressionList(node.arguments);
     return glue.generateTypeRepresentation(node.dartType, arguments);
   }
 
   visitFunctionExpression(tree_ir.FunctionExpression node) {
     // FunctionExpressions are currently unused.
     // We might need them if we want to emit raw JS nested functions.
     throw 'FunctionExpressions should not be used';
   }
 }