Support map and list literals in analyzer2dart.

sdk/lib/_internal/compiler/implementation/cps_ir/cps_ir_nodes.dart

 // Copyright (c) 2013, 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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 463 matching lines @@
   values.ConstantValue get constant => null;
 
   accept(Visitor visitor) => visitor.visitReifyTypeVar(this);
 }
 
 class LiteralList extends Primitive {
   /// The List type being created; this is not the type argument.
   final GenericType type;
   final List<Reference> values;
 
-  LiteralList(this.type, List<Primitive> values)
+  LiteralList(this.type, Iterable<Primitive> values)
       : this.values = _referenceList(values);
 
   accept(Visitor visitor) => visitor.visitLiteralList(this);
 }
 
+class LiteralMapEntry {
+  final Reference key;
+  final Reference value;
+
+  LiteralMapEntry(Primitive key, Primitive value)
+      : this.key = new Reference(key),
+        this.value = new Reference(value);
+}
+
 class LiteralMap extends Primitive {
   final GenericType type;
-  final List<Reference> keys;
-  final List<Reference> values;
+  final List<LiteralMapEntry> entries;
 
-  LiteralMap(this.type, List<Primitive> keys, List<Primitive> values)
-      : this.keys = _referenceList(keys),
-        this.values = _referenceList(values);
+  LiteralMap(this.type, this.entries);
 
   accept(Visitor visitor) => visitor.visitLiteralMap(this);
 }
 
 /// Create a non-recursive function.
 class CreateFunction extends Primitive {
   final FunctionDefinition definition;
 
   CreateFunction(this.definition);
 
@@ skipping 51 matching lines @@
 
   accept(Visitor visitor) => visitor.visitFunctionDefinition(this);
 
   /// Returns `true` if this function is abstract.
   ///
   /// If `true`, [body] and [returnContinuation] are `null` and [localConstants]
   /// is empty.
   bool get isAbstract => body == null;
 }
 
-List<Reference> _referenceList(List<Definition> definitions) {
+List<Reference> _referenceList(Iterable<Definition> definitions) {
   return definitions.map((e) => new Reference(e)).toList();
 }
 
 abstract class Visitor<T> {
   T visit(Node node) => node.accept(this);
   // Abstract classes.
   T visitNode(Node node) => null;
   T visitExpression(Expression node) => visitNode(node);
   T visitDefinition(Definition node) => visitNode(node);
   T visitPrimitive(Primitive node) => visitDefinition(node);
@@ skipping 144 matching lines @@
 
   processLiteralList(LiteralList node) {}
   visitLiteralList(LiteralList node) {
     processLiteralList(node);
     node.values.forEach(processReference);
   }
 
   processLiteralMap(LiteralMap node) {}
   visitLiteralMap(LiteralMap node) {
     processLiteralMap(node);
-    for (int i = 0; i < node.keys.length; i++) {
-      processReference(node.keys[i]);
-      processReference(node.values[i]);
+    for (LiteralMapEntry entry in node.entries) {
+      processReference(entry.key);
+      processReference(entry.value);
     }
   }
 
   processConstant(Constant node) {}
   visitConstant(Constant node) => processConstant(node);
 
   processThis(This node) {}
   visitThis(This node) => processThis(node);
 
   processReifyTypeVar(ReifyTypeVar node) {}
@@ skipping 132 matching lines @@
 
   void visitBranch(Branch node) {
     visit(node.condition);
   }
 
   void visitLiteralList(LiteralList node) {
     node.values.forEach(visitReference);
   }
 
   void visitLiteralMap(LiteralMap node) {
-    for (int i = 0; i < node.keys.length; ++i) {
-      visitReference(node.keys[i]);
-      visitReference(node.values[i]);
+    for (LiteralMapEntry entry in node.entries) {
+      visitReference(entry.key);
+      visitReference(entry.value);
     }
   }
 
   void visitTypeOperator(TypeOperator node) {
     visitReference(node.receiver);
   }
 
   void visitConstant(Constant node) {
   }
 
@@ skipping 34 matching lines @@
       release(node.parameters[i]);
     }
   }
 
   void visitIsTrue(IsTrue node) {
     visitReference(node.value);
   }
 
 }