Support map and list literals in analyzer2dart.

sdk/lib/_internal/compiler/implementation/cps_ir/cps_ir_builder.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.
 
 library dart2js.ir_builder;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_backend/dart_backend.dart' show DartBackend;
 import '../dart_types.dart';
@@ skipping 109 matching lines @@
     ir.InvokeContinuation invoke = new ir.InvokeContinuation.uninitialized();
     builder.add(invoke);
     _invocations.add(invoke);
     _environments.add(builder.environment);
     builder._current = null;
     // TODO(kmillikin): Can we set builder.environment to null to make it
     // less likely to mutate it?
   }
 }
 
+/// Function for building a node in the context of the current builder.
+typedef ir.Node BuildFunction(node);
+
 /// Function for building nodes in the context of the provided [builder].
 typedef ir.Node SubbuildFunction(IrBuilder builder);
 
 /// Mixin that provides encapsulated access to nested builders.
 abstract class IrBuilderMixin<N> {
   IrBuilder _irBuilder;
 
   /// Execute [f] with [builder] as the current builder.
   withBuilder(IrBuilder builder, f()) {
     assert(builder != null);
@@ skipping 240 matching lines @@
   ir.Constant buildNullLiteral() {
     return _buildPrimitiveConstant(state.constantSystem.createNull());
   }
 
   /// Create a string literal.
   ir.Constant buildStringLiteral(String value) {
     return _buildPrimitiveConstant(
         state.constantSystem.createString(new ast.DartString.literal(value)));
   }
 
+  /// Creates a non-constant list literal of the provided [type] and with the
+  /// provided [values].
+  ir.Primitive buildListLiteral(InterfaceType type,
+                                Iterable<ir.Primitive> values) {
+    assert(isOpen);
+    ir.Primitive result = new ir.LiteralList(type, values);
+    add(new ir.LetPrim(result));
+    return result;
+  }
+
+  /// Creates a non-constant map literal of the provided [type] and with the
+  /// entries build from the [keys] and [values] using [build].
+  ir.Primitive buildMapLiteral(InterfaceType type,
+                               Iterable keys,
+                               Iterable values,
+                               BuildFunction build) {
+    assert(isOpen);
+    List<ir.LiteralMapEntry> entries = <ir.LiteralMapEntry>[];
+    Iterator key = keys.iterator;
+    Iterator value = values.iterator;
+    while (key.moveNext() && value.moveNext()) {
+      entries.add(new ir.LiteralMapEntry(
+          build(key.current), build(value.current)));
+    }
+    assert(!key.moveNext() && !value.moveNext());
+    ir.Primitive result = new ir.LiteralMap(type, entries);
+    add(new ir.LetPrim(result));
+    return result;
+  }
+
   /// Creates a conditional expression with the provided [condition] where the
   /// then and else expression are created through the [buildThenExpression] and
   /// [buildElseExpression] functions, respectively.
   ir.Primitive buildConditional(
       ir.Primitive condition,
       ir.Primitive buildThenExpression(IrBuilder builder),
       ir.Primitive buildElseExpression(IrBuilder builder)) {
 
     assert(isOpen);
 
@@ skipping 389 matching lines @@
       value = buildNullLiteral();
     }
     add(new ir.InvokeContinuation(state.returnContinuation, [value]));
     _current = null;
   }
 
   /// Create a blocks of [statements] by applying [build] to all reachable
   /// statements. The first statement is assumed to be reachable.
   // TODO(johnniwinther): Type [statements] as `Iterable` when `NodeList` uses
   // `List` instead of `Link`.
-  void buildBlock(var statements, build(statement)) {
+  void buildBlock(var statements, BuildFunction build) {
     // Build(Block(stamements), C) = C'
     //   where C' = statements.fold(Build, C)
     assert(isOpen);
     return buildSequence(statements, build);
   }
 
   /// Creates a sequence of [nodes] by applying [build] to all reachable nodes.
   ///
   /// The first node in the sequence does not need to be reachable.
   // TODO(johnniwinther): Type [nodes] as `Iterable` when `NodeList` uses
   // `List` instead of `Link`.
-  void buildSequence(var nodes, build(node)) {
+  void buildSequence(var nodes, BuildFunction build) {
     for (var node in nodes) {
       if (!isOpen) return;
       build(node);
     }
   }
 
 
   // Build(BreakStatement L, C) = C[InvokeContinuation(...)]
   //
   // The continuation and arguments are filled in later after translating
@@ skipping 238 matching lines @@
     index = 0;
     for (int i = 0; i < environment.length; ++i) {
       if (common[i] == null) {
         environment.index2value[i] = parameters[index++];
       }
     }
 
     return join;
   }
 }