Support map and list literals in analyzer2dart.

sdk/lib/_internal/compiler/implementation/dart_backend/backend_ast_emitter.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 backend_ast_emitter;
 
 import 'tree_ir_nodes.dart' as tree;
 import 'backend_ast_nodes.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
@@ skipping 313 matching lines @@
     name = variable.element == null ? '$prefix$counter' : variable.element.name;
     while (!usedVariableNames.add(name)) {
       ++counter;
       name = '$prefix$counter';
     }
     variableNames[variable] = name;
 
     // Synthesize an element for the variable
     if (variable.element == null || name != variable.element.name) {
       // TODO(johnniwinther): Replace by synthetic [Entity].
-      variable.element = new modelx.LocalVariableElementX.synthetic(
+      variable.element = new _SyntheticLocalVariableElement(
           name,
           functionElement,
           variableList);
     }
     return name;
   }
 
   String getConstantName(VariableElement element) {
     assert(element.kind == ElementKind.VARIABLE);
     if (element.enclosingElement != functionElement) {
@@ skipping 162 matching lines @@
   }
 
   Expression visitLiteralList(tree.LiteralList exp) {
     return new LiteralList(
         exp.values.map(visitExpression).toList(growable: false),
         typeArgument: emitOptionalType(exp.type.typeArguments.single));
   }
 
   Expression visitLiteralMap(tree.LiteralMap exp) {
     List<LiteralMapEntry> entries = new List<LiteralMapEntry>.generate(
-        exp.values.length,
-        (i) => new LiteralMapEntry(visitExpression(exp.keys[i]),
-                                   visitExpression(exp.values[i])));
+        exp.entries.length,
+        (i) => new LiteralMapEntry(visitExpression(exp.entries[i].key),
+                                   visitExpression(exp.entries[i].value)));
     List<TypeAnnotation> typeArguments = exp.type.treatAsRaw
         ? null
-        : exp.type.typeArguments.map(createTypeAnnotation).toList(growable: false);
+        : exp.type.typeArguments.map(createTypeAnnotation)
+             .toList(growable: false);
     return new LiteralMap(entries, typeArguments: typeArguments);
   }
 
   Expression visitTypeOperator(tree.TypeOperator exp) {
     return new TypeOperator(visitExpression(exp.receiver),
                             exp.operator,
                             createTypeAnnotation(exp.type));
   }
 
   List<Argument> emitArguments(tree.Invoke exp) {
@@ skipping 357 matching lines @@
     }
   }
 
   visitVariable(tree.Variable variable) {
     if (shadowedParameters.contains(variable)) {
       hasShadowedUse.add(variable);
     }
   }
 
 }
+
+// TODO(johnniwinther): Remove this when the dart `backend_ast` does not need
+// [Element] for entities.
+class _SyntheticLocalVariableElement extends modelx.VariableElementX
+    implements LocalVariableElement {
+
+  _SyntheticLocalVariableElement(String name,
+                                 ExecutableElement enclosingElement,
+                                 modelx.VariableList variables)
+      : super(name, ElementKind.VARIABLE, enclosingElement, variables, null);
+
+  ExecutableElement get executableContext => enclosingElement;
+
+  ExecutableElement get memberContext => executableContext.memberContext;
+
+  bool get isLocal => true;
+
+  LibraryElement get implementationLibrary => enclosingElement.library;
+}