addressing 3 previous review comments

frog/gen.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 2327 matching lines @@
     // Call the constructor on the type we want to construct.
     // NOTE: this is important for correct type checking of factories.
     // If the user calls "new Interface()" we want the result type to be the
     // interface, not the class.
     var target = new Value.type(type, typeRef.span);
     return m.invoke(this, node, target, _makeArgs(node.arguments));
   }
 
   visitListExpression(ListExpression node) {
     var argValues = [];
-    //var listType = node.isConst ? world.immutableListType : world.listType;
     var listType = world.listType;
     var type = world.varType;
     if (node.itemType != null) {
       type = method.resolveType(node.itemType, true);
       if (node.isConst && (type is ParameterType || type.hasTypeParams)) {
         world.error('type parameter cannot be used in const list literals');
       }
       listType = listType.getOrMakeConcreteType([type]);
     }
     for (var item in node.values) {
@@ skipping 12 matching lines @@
   }
 
 
   visitMapExpression(MapExpression node) {
     // Special case the empty non-const map.
     if (node.items.length == 0 && !node.isConst) {
       return world.mapType.getConstructor('').invoke(this, node,
         new Value.type(world.mapType, node.span), Arguments.EMPTY);
     }
 
-    var values = new List<Value>();
+    var values = <Value>[];
     var valueType = world.varType, keyType = world.stringType;
     var mapType = world.mapType; // TODO(jimhug): immutable type?
     if (node.valueType !== null) {
       if (node.keyType !== null) {
         keyType = method.resolveType(node.keyType, true);
         // TODO(jimhug): Would be nice to allow arbitrary keys here (this is
         // currently not allowed by the spec).
         if (!keyType.isString) {
           world.error('the key type of a map literal must be "String"',
               keyType.span);
         }
-        if (node.isConst && (keyType is ParameterType || keyType.hasTypeParams)) {
+        if (node.isConst &&
+            (keyType is ParameterType || keyType.hasTypeParams)) {
           world.error('type parameter cannot be used in const map literals');
         }
       }
 
       valueType = method.resolveType(node.valueType, true);
-      if (node.isConst && (valueType is ParameterType || valueType.hasTypeParams)) {
+      if (node.isConst &&
+          (valueType is ParameterType || valueType.hasTypeParams)) {
         world.error('type parameter cannot be used in const map literals');
       }
 
       mapType = mapType.getOrMakeConcreteType([keyType, valueType]);
     }
 
     for (int i = 0; i < node.items.length; i += 2) {
       var key = visitTypedValue(node.items[i], keyType);
       if (node.isConst && !key.isConst) {
         world.error('const map can only contain const keys', key.span);
       }
       values.add(key);
 
-      var value = visitTypedValue(node.items[i+1], valueType);
+      var value = visitTypedValue(node.items[i + 1], valueType);
       if (node.isConst && !value.isConst) {
         world.error('const map can only contain const values', value.span);
       }
       values.add(value);
     }
 
     var ret = new MapValue(values, node.isConst, mapType, node.span);
     if (ret.isConst) return ret.getGlobalValue();
     return ret;
   }
@@ skipping 202 matching lines @@
       result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }