Lower map literals to constructor or function calls in builder

pkg/compiler/lib/src/tree_ir/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/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 294 matching lines @@
   final List<Expression> values;
 
   LiteralList(this.type, this.values);
 
   accept(ExpressionVisitor visitor) => visitor.visitLiteralList(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitLiteralList(this, arg);
   }
 }
 
-class LiteralMapEntry {
-  Expression key;
-  Expression value;
-
-  LiteralMapEntry(this.key, this.value);
-}
-
-class LiteralMap extends Expression {
-  final InterfaceType type;
-  final List<LiteralMapEntry> entries;
-
-  LiteralMap(this.type, this.entries);
-
-  accept(ExpressionVisitor visitor) => visitor.visitLiteralMap(this);
-  accept1(ExpressionVisitor1 visitor, arg) {
-    return visitor.visitLiteralMap(this, arg);
-  }
-}
-
 /// Type test or type cast.
 ///
 /// Note that if this is a type test, then [type] cannot be `Object`, `dynamic`,
 /// or the `Null` type. These cases are compiled to other node types.
 class TypeOperator extends Expression {
   Expression value;
   final DartType type;
   final List<Expression> typeArguments;
   final bool isTypeTest;
 
@@ skipping 648 matching lines @@
   E visitInvokeMethod(InvokeMethod node);
   E visitInvokeMethodDirectly(InvokeMethodDirectly node);
   E visitInvokeConstructor(InvokeConstructor node);
   E visitOneShotInterceptor(OneShotInterceptor node);
   E visitConstant(Constant node);
   E visitThis(This node);
   E visitConditional(Conditional node);
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
-  E visitLiteralMap(LiteralMap node);
   E visitTypeOperator(TypeOperator node);
   E visitGetField(GetField node);
   E visitSetField(SetField node);
   E visitGetStatic(GetStatic node);
   E visitSetStatic(SetStatic node);
   E visitGetTypeTestProperty(GetTypeTestProperty node);
   E visitCreateBox(CreateBox node);
   E visitCreateInstance(CreateInstance node);
   E visitReifyRuntimeType(ReifyRuntimeType node);
   E visitReadTypeVariable(ReadTypeVariable node);
@@ skipping 17 matching lines @@
   E visitInvokeMethod(InvokeMethod node, A arg);
   E visitInvokeMethodDirectly(InvokeMethodDirectly node, A arg);
   E visitInvokeConstructor(InvokeConstructor node, A arg);
   E visitOneShotInterceptor(OneShotInterceptor node, A arg);
   E visitConstant(Constant node, A arg);
   E visitThis(This node, A arg);
   E visitConditional(Conditional node, A arg);
   E visitLogicalOperator(LogicalOperator node, A arg);
   E visitNot(Not node, A arg);
   E visitLiteralList(LiteralList node, A arg);
-  E visitLiteralMap(LiteralMap node, A arg);
   E visitTypeOperator(TypeOperator node, A arg);
   E visitGetField(GetField node, A arg);
   E visitSetField(SetField node, A arg);
   E visitGetStatic(GetStatic node, A arg);
   E visitSetStatic(SetStatic node, A arg);
   E visitGetTypeTestProperty(GetTypeTestProperty node, A arg);
   E visitCreateBox(CreateBox node, A arg);
   E visitCreateInstance(CreateInstance node, A arg);
   E visitReifyRuntimeType(ReifyRuntimeType node, A arg);
   E visitReadTypeVariable(ReadTypeVariable node, A arg);
@@ skipping 98 matching lines @@
   }
 
   visitNot(Not node) {
     visitExpression(node.operand);
   }
 
   visitLiteralList(LiteralList node) {
     node.values.forEach(visitExpression);
   }
 
-  visitLiteralMap(LiteralMap node) {
-    node.entries.forEach((LiteralMapEntry entry) {
-      visitExpression(entry.key);
-      visitExpression(entry.value);
-    });
-  }
-
   visitTypeOperator(TypeOperator node) {
     visitExpression(node.value);
     node.typeArguments.forEach(visitExpression);
   }
 
   visitLabeledStatement(LabeledStatement node) {
     visitStatement(node.body);
     visitStatement(node.next);
   }
 
@@ skipping 207 matching lines @@
   visitNot(Not node) {
     node.operand = visitExpression(node.operand);
     return node;
   }
 
   visitLiteralList(LiteralList node) {
     _replaceExpressions(node.values);
     return node;
   }
 
-  visitLiteralMap(LiteralMap node) {
-    node.entries.forEach((LiteralMapEntry entry) {
-      entry.key = visitExpression(entry.key);
-      entry.value = visitExpression(entry.value);
-    });
-    return node;
-  }
-
   visitTypeOperator(TypeOperator node) {
     node.value = visitExpression(node.value);
     _replaceExpressions(node.typeArguments);
     return node;
   }
 
   visitLabeledStatement(LabeledStatement node) {
     node.body = visitStatement(node.body);
     node.next = visitStatement(node.next);
     return node;
@@ skipping 202 matching lines @@
 
   /// Number of uses of the current fallthrough target.
   int get useCount => _stack.last.useCount;
 
   /// Indicate that a statement will fall through to the current fallthrough
   /// target.
   void use() {
     ++_stack.last.useCount;
   }
 }