dart2dart: Support for all constants in new backend.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_codegen.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 dart_codegen;
 
 import 'dart_tree.dart' as tree;
 import 'dart_printer.dart';
 import 'dart_tree_printer.dart' show TreePrinter;
 import '../tree/tree.dart' as frontend;
@@ skipping 317 matching lines @@
 
     visitStatement(stmt.next);
   }
 
   Expression visitConstant(tree.Constant exp) {
     return emitConstant(exp.value);
   }
 
   Expression visitLiteralList(tree.LiteralList exp) {
     return new LiteralList(
-        exp.values.map(visitExpression).toList(growable: false));
+        exp.values.map(visitExpression).toList(growable: false),
+        isConst: exp.constant != null,
+        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])));
-    return new LiteralMap(entries);
+    List<TypeAnnotation> typeArguments = exp.type.treatAsRaw
+        ? null
+        : exp.type.typeArguments.mapToList(emitType);
+    return new LiteralMap(entries,
+                          isConst: exp.constant != null,
+                          typeArguments: typeArguments);
   }
 
   List<Argument> emitArguments(tree.Invoke exp) {
     List<tree.Expression> args = exp.arguments;
     int positionalArgumentCount = exp.selector.positionalArgumentCount;
     List<Argument> result = new List<Argument>.generate(positionalArgumentCount,
         (i) => visitExpression(exp.arguments[i]));
     for (int i = 0; i < exp.selector.namedArgumentCount; ++i) {
       result.add(new NamedArgument(exp.selector.namedArguments[i],
           visitExpression(exp.arguments[positionalArgumentCount + i])));
@@ skipping 58 matching lines @@
 
       default:
         throw "Unexpected selector in InvokeMethod: ${exp.selector.kind}";
     }
   }
 
   Expression visitInvokeConstructor(tree.InvokeConstructor exp) {
     List args = emitArguments(exp);
     FunctionElement constructor = exp.target;
     String name = constructor.name.isEmpty ? null : constructor.name;
-    return new CallNew(emitType(exp.type), args, constructorName: name)
+    return new CallNew(emitType(exp.type),
+                       args,
+                       constructorName: name,
+                       isConst: exp.constant != null)
                ..constructor = constructor
                ..dartType = exp.type;
   }
-
-  Expression visitInvokeConstConstructor(tree.InvokeConstConstructor exp) {
-    List args = emitArguments(exp);
-    FunctionElement constructor = exp.target;
-    String name = constructor.name.isEmpty ? null : constructor.name;
-    return new CallNew(emitType(exp.type), args, constructorName: name,
-                       isConst: true)
-               ..constructor = constructor
-               ..dartType = exp.type;
-  }
 
   Expression visitConcatenateStrings(tree.ConcatenateStrings exp) {
     List args = exp.arguments.map(visitExpression).toList(growable:false);
     return new StringConcat(args);
   }
 
   Expression visitConditional(tree.Conditional exp) {
     return new Conditional(
         visitExpression(exp.condition),
         visitExpression(exp.thenExpression),
@@ skipping 44 matching lines @@
     if (type.treatAsDynamic) {
       return null;
     } else {
       return emitType(type);
     }
   }
 
   Expression emitConstant(dart2js.Constant constant) {
     if (constant is dart2js.PrimitiveConstant) {
       return new Literal(constant);
-    } else if (constant is dart2js.ListConstant) {
-      return new LiteralList(
-          constant.entries.map(emitConstant).toList(growable: false),
-          isConst: true);
-    } else if (constant is dart2js.MapConstant) {
-      List<LiteralMapEntry> entries = <LiteralMapEntry>[];
-      for (var i = 0; i < constant.keys.length; i++) {
-        entries.add(new LiteralMapEntry(
-            emitConstant(constant.keys.entries[i]),
-            emitConstant(constant.values[i])));
-      }
-      return new LiteralMap(entries, isConst: true);
+    } else if (constant is dart2js.ConstructedConstant &&
+               constant.isLiteralSymbol) {
+      dart2js.StringConstant nameConstant = constant.fields[0];
+      String nameString = nameConstant.value.slowToString();
+      return new LiteralSymbol(nameString);
+    } else if (constant is dart2js.FunctionConstant) {
+      return new Identifier(constant.element.name)
+                 ..element = constant.element;
+    } else if (constant is dart2js.TypeConstant) {
+      GenericType type = constant.representedType;
+      return new Identifier(type.name)
+                 ..element = type.element;
     } else {
-      if (constant is dart2js.ConstructedConstant && constant.isLiteralSymbol) {
-        dart2js.StringConstant nameConstant = constant.fields[0];
-        String nameString = nameConstant.value.slowToString();
-        return new LiteralSymbol(nameString);
-      } else {
-        throw "Unsupported constant: $constant";
-      }
+      throw "Unsupported constant: $constant";
     }
   }
 }