Support map and list literals in analyzer2dart.

sdk/lib/_internal/compiler/implementation/dart_backend/tree_ir_nodes.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 tree_ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import '../dart_types.dart' show DartType, GenericType;
@@ skipping 205 matching lines @@
 
 class LiteralList extends Expression {
   final GenericType type;
   final List<Expression> values;
 
   LiteralList(this.type, this.values);
 
   accept(ExpressionVisitor visitor) => visitor.visitLiteralList(this);
 }
 
+class LiteralMapEntry {
+  Expression key;
+  Expression value;
+
+  LiteralMapEntry(this.key, this.value);
+}
+
 class LiteralMap extends Expression {
   final GenericType type;
-  final List<Expression> keys;
-  final List<Expression> values;
+  final List<LiteralMapEntry> entries;
 
-  LiteralMap(this.type, this.keys, this.values);
+  LiteralMap(this.type, this.entries);
 
   accept(ExpressionVisitor visitor) => visitor.visitLiteralMap(this);
 }
 
 class TypeOperator extends Expression {
   Expression receiver;
   final DartType type;
   final String operator;
 
   TypeOperator(this.receiver, this.type, this.operator) ;
@@ skipping 346 matching lines @@
 
   visitNot(Not node) {
     visitExpression(node.operand);
   }
 
   visitLiteralList(LiteralList node) {
     node.values.forEach(visitExpression);
   }
 
   visitLiteralMap(LiteralMap node) {
-    for (int i=0; i<node.keys.length; i++) {
-      visitExpression(node.keys[i]);
-      visitExpression(node.values[i]);
-    }
+    node.entries.forEach((LiteralMapEntry entry) {
+      visitExpression(entry.key);
+      visitExpression(entry.value);
+    });
   }
 
   visitTypeOperator(TypeOperator node) {
     visitExpression(node.receiver);
   }
 
   visitFunctionExpression(FunctionExpression node) {
     visitFunctionDefinition(node.definition);
   }
 
@@ skipping 35 matching lines @@
   visitFunctionDeclaration(FunctionDeclaration node) {
     visitFunctionDefinition(node.definition);
     visitStatement(node.next);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     visitExpression(node.expression);
     visitStatement(node.next);
   }
 }